1 // Copyright (C) 2018 The Android Open Source Project
2 // Copyright (C) 2018 Google Inc.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15
16 // Autogenerated module VkSubDecoder
17 //
18 // (impl) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
19 // -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
20 //
21 // Please do not modify directly;
22 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
23 // or directly from Python by defining:
24 // VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
25 // VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
26 // CEREAL_OUTPUT_DIR: Where to put the generated sources.
27 //
28 // python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
29 // $CEREAL_OUTPUT_DIR
30 //
31 #define MAX_STACK_ITEMS 16
32 #define MAX_PACKET_LENGTH (400 * 1024 * 1024) // 400MB
subDecode(VulkanMemReadingStream * readStream,VulkanDispatch * vk,void * boxed_dispatchHandle,void * dispatchHandle,VkDeviceSize dataSize,const void * pData,const VkDecoderContext & context)33 size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* boxed_dispatchHandle,
34 void* dispatchHandle, VkDeviceSize dataSize, const void* pData,
35 const VkDecoderContext& context) {
36 auto& metricsLogger = *context.metricsLogger;
37 uint32_t count = 0;
38 unsigned char* buf = (unsigned char*)pData;
39 android::base::BumpPool* pool = readStream->pool();
40 unsigned char* ptr = (unsigned char*)pData;
41 const unsigned char* const end = (const unsigned char*)buf + dataSize;
42 VkDecoderGlobalState* globalstate = VkDecoderGlobalState::get();
43 while (end - ptr >= 8) {
44 uint32_t opcode = *(uint32_t*)ptr;
45 uint32_t packetLen = *(uint32_t*)(ptr + 4);
46
47 // packetLen should be at least 8 (op code and packet length) and should not be excessively
48 // large
49 if (packetLen < 8 || packetLen > MAX_PACKET_LENGTH) {
50 WARN("Bad packet length %d detected, subdecode may fail", packetLen);
51 metricsLogger.logMetricEvent(MetricEventBadPacketLength{.len = packetLen});
52 }
53
54 if (end - ptr < packetLen) return ptr - (unsigned char*)buf;
55 readStream->setBuf((uint8_t*)(ptr + 8));
56 uint8_t* readStreamPtr = readStream->getBuf();
57 uint8_t** readStreamPtrPtr = &readStreamPtr;
58 switch (opcode) {
59 #ifdef VK_VERSION_1_0
60 case OP_vkBeginCommandBuffer: {
61 android::base::beginTrace("vkBeginCommandBuffer subdecode");
62 const VkCommandBufferBeginInfo* pBeginInfo;
63 VkCommandBufferBeginInfo stack_pBeginInfo[1];
64 pBeginInfo = (VkCommandBufferBeginInfo*)stack_pBeginInfo;
65 reservedunmarshal_VkCommandBufferBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
66 (VkCommandBufferBeginInfo*)(pBeginInfo),
67 readStreamPtrPtr);
68 if (pBeginInfo) {
69 transform_tohost_VkCommandBufferBeginInfo(
70 globalstate, (VkCommandBufferBeginInfo*)(pBeginInfo));
71 }
72 VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
73 vkBeginCommandBuffer_VkResult_return = this->on_vkBeginCommandBuffer(
74 pool, (VkCommandBuffer)(boxed_dispatchHandle), pBeginInfo, context);
75 if ((vkBeginCommandBuffer_VkResult_return) == VK_ERROR_DEVICE_LOST)
76 this->on_DeviceLost();
77 this->on_CheckOutOfMemory(vkBeginCommandBuffer_VkResult_return, opcode, context);
78 android::base::endTrace();
79 break;
80 }
81 case OP_vkEndCommandBuffer: {
82 android::base::beginTrace("vkEndCommandBuffer subdecode");
83 VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
84 vkEndCommandBuffer_VkResult_return = this->on_vkEndCommandBuffer(
85 pool, (VkCommandBuffer)(boxed_dispatchHandle), context);
86 if ((vkEndCommandBuffer_VkResult_return) == VK_ERROR_DEVICE_LOST)
87 this->on_DeviceLost();
88 this->on_CheckOutOfMemory(vkEndCommandBuffer_VkResult_return, opcode, context);
89 android::base::endTrace();
90 break;
91 }
92 case OP_vkResetCommandBuffer: {
93 android::base::beginTrace("vkResetCommandBuffer subdecode");
94 VkCommandBufferResetFlags flags;
95 memcpy((VkCommandBufferResetFlags*)&flags, *readStreamPtrPtr,
96 sizeof(VkCommandBufferResetFlags));
97 *readStreamPtrPtr += sizeof(VkCommandBufferResetFlags);
98 VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
99 vkResetCommandBuffer_VkResult_return = this->on_vkResetCommandBuffer(
100 pool, (VkCommandBuffer)(boxed_dispatchHandle), flags);
101 if ((vkResetCommandBuffer_VkResult_return) == VK_ERROR_DEVICE_LOST)
102 this->on_DeviceLost();
103 this->on_CheckOutOfMemory(vkResetCommandBuffer_VkResult_return, opcode, context);
104 android::base::endTrace();
105 break;
106 }
107 case OP_vkCmdBindPipeline: {
108 android::base::beginTrace("vkCmdBindPipeline subdecode");
109 VkPipelineBindPoint pipelineBindPoint;
110 VkPipeline pipeline;
111 memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
112 sizeof(VkPipelineBindPoint));
113 *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
114 uint64_t cgen_var_0;
115 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
116 *readStreamPtrPtr += 1 * 8;
117 *(VkPipeline*)&pipeline = (VkPipeline)unbox_VkPipeline((VkPipeline)(*&cgen_var_0));
118 this->on_vkCmdBindPipeline(pool, (VkCommandBuffer)(boxed_dispatchHandle),
119 pipelineBindPoint, pipeline);
120 android::base::endTrace();
121 break;
122 }
123 case OP_vkCmdSetViewport: {
124 android::base::beginTrace("vkCmdSetViewport subdecode");
125 uint32_t firstViewport;
126 uint32_t viewportCount;
127 const VkViewport* pViewports;
128 VkViewport stack_pViewports[MAX_STACK_ITEMS];
129 memcpy((uint32_t*)&firstViewport, *readStreamPtrPtr, sizeof(uint32_t));
130 *readStreamPtrPtr += sizeof(uint32_t);
131 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
132 *readStreamPtrPtr += sizeof(uint32_t);
133 if (((viewportCount)) <= MAX_STACK_ITEMS) {
134 pViewports = (VkViewport*)stack_pViewports;
135 } else {
136 readStream->alloc((void**)&pViewports,
137 ((viewportCount)) * sizeof(const VkViewport));
138 }
139 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
140 reservedunmarshal_VkViewport(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
141 (VkViewport*)(pViewports + i), readStreamPtrPtr);
142 }
143 if (pViewports) {
144 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
145 transform_tohost_VkViewport(globalstate, (VkViewport*)(pViewports + i));
146 }
147 }
148 vk->vkCmdSetViewport((VkCommandBuffer)dispatchHandle, firstViewport, viewportCount,
149 pViewports);
150 android::base::endTrace();
151 break;
152 }
153 case OP_vkCmdSetScissor: {
154 android::base::beginTrace("vkCmdSetScissor subdecode");
155 uint32_t firstScissor;
156 uint32_t scissorCount;
157 const VkRect2D* pScissors;
158 VkRect2D stack_pScissors[MAX_STACK_ITEMS];
159 memcpy((uint32_t*)&firstScissor, *readStreamPtrPtr, sizeof(uint32_t));
160 *readStreamPtrPtr += sizeof(uint32_t);
161 memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
162 *readStreamPtrPtr += sizeof(uint32_t);
163 if (((scissorCount)) <= MAX_STACK_ITEMS) {
164 pScissors = (VkRect2D*)stack_pScissors;
165 } else {
166 readStream->alloc((void**)&pScissors,
167 ((scissorCount)) * sizeof(const VkRect2D));
168 }
169 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
170 reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
171 (VkRect2D*)(pScissors + i), readStreamPtrPtr);
172 }
173 if (pScissors) {
174 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
175 transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pScissors + i));
176 }
177 }
178 vk->vkCmdSetScissor((VkCommandBuffer)dispatchHandle, firstScissor, scissorCount,
179 pScissors);
180 android::base::endTrace();
181 break;
182 }
183 case OP_vkCmdSetLineWidth: {
184 android::base::beginTrace("vkCmdSetLineWidth subdecode");
185 float lineWidth;
186 memcpy((float*)&lineWidth, *readStreamPtrPtr, sizeof(float));
187 *readStreamPtrPtr += sizeof(float);
188 vk->vkCmdSetLineWidth((VkCommandBuffer)dispatchHandle, lineWidth);
189 android::base::endTrace();
190 break;
191 }
192 case OP_vkCmdSetDepthBias: {
193 android::base::beginTrace("vkCmdSetDepthBias subdecode");
194 float depthBiasConstantFactor;
195 float depthBiasClamp;
196 float depthBiasSlopeFactor;
197 memcpy((float*)&depthBiasConstantFactor, *readStreamPtrPtr, sizeof(float));
198 *readStreamPtrPtr += sizeof(float);
199 memcpy((float*)&depthBiasClamp, *readStreamPtrPtr, sizeof(float));
200 *readStreamPtrPtr += sizeof(float);
201 memcpy((float*)&depthBiasSlopeFactor, *readStreamPtrPtr, sizeof(float));
202 *readStreamPtrPtr += sizeof(float);
203 vk->vkCmdSetDepthBias((VkCommandBuffer)dispatchHandle, depthBiasConstantFactor,
204 depthBiasClamp, depthBiasSlopeFactor);
205 android::base::endTrace();
206 break;
207 }
208 case OP_vkCmdSetBlendConstants: {
209 android::base::beginTrace("vkCmdSetBlendConstants subdecode");
210 float blendConstants[4];
211 memcpy((float*)blendConstants, *readStreamPtrPtr, 4 * sizeof(const float));
212 *readStreamPtrPtr += 4 * sizeof(const float);
213 vk->vkCmdSetBlendConstants((VkCommandBuffer)dispatchHandle, blendConstants);
214 android::base::endTrace();
215 break;
216 }
217 case OP_vkCmdSetDepthBounds: {
218 android::base::beginTrace("vkCmdSetDepthBounds subdecode");
219 float minDepthBounds;
220 float maxDepthBounds;
221 memcpy((float*)&minDepthBounds, *readStreamPtrPtr, sizeof(float));
222 *readStreamPtrPtr += sizeof(float);
223 memcpy((float*)&maxDepthBounds, *readStreamPtrPtr, sizeof(float));
224 *readStreamPtrPtr += sizeof(float);
225 vk->vkCmdSetDepthBounds((VkCommandBuffer)dispatchHandle, minDepthBounds,
226 maxDepthBounds);
227 android::base::endTrace();
228 break;
229 }
230 case OP_vkCmdSetStencilCompareMask: {
231 android::base::beginTrace("vkCmdSetStencilCompareMask subdecode");
232 VkStencilFaceFlags faceMask;
233 uint32_t compareMask;
234 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
235 sizeof(VkStencilFaceFlags));
236 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
237 memcpy((uint32_t*)&compareMask, *readStreamPtrPtr, sizeof(uint32_t));
238 *readStreamPtrPtr += sizeof(uint32_t);
239 vk->vkCmdSetStencilCompareMask((VkCommandBuffer)dispatchHandle, faceMask,
240 compareMask);
241 android::base::endTrace();
242 break;
243 }
244 case OP_vkCmdSetStencilWriteMask: {
245 android::base::beginTrace("vkCmdSetStencilWriteMask subdecode");
246 VkStencilFaceFlags faceMask;
247 uint32_t writeMask;
248 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
249 sizeof(VkStencilFaceFlags));
250 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
251 memcpy((uint32_t*)&writeMask, *readStreamPtrPtr, sizeof(uint32_t));
252 *readStreamPtrPtr += sizeof(uint32_t);
253 vk->vkCmdSetStencilWriteMask((VkCommandBuffer)dispatchHandle, faceMask, writeMask);
254 android::base::endTrace();
255 break;
256 }
257 case OP_vkCmdSetStencilReference: {
258 android::base::beginTrace("vkCmdSetStencilReference subdecode");
259 VkStencilFaceFlags faceMask;
260 uint32_t reference;
261 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
262 sizeof(VkStencilFaceFlags));
263 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
264 memcpy((uint32_t*)&reference, *readStreamPtrPtr, sizeof(uint32_t));
265 *readStreamPtrPtr += sizeof(uint32_t);
266 vk->vkCmdSetStencilReference((VkCommandBuffer)dispatchHandle, faceMask, reference);
267 android::base::endTrace();
268 break;
269 }
270 case OP_vkCmdBindDescriptorSets: {
271 android::base::beginTrace("vkCmdBindDescriptorSets subdecode");
272 VkPipelineBindPoint pipelineBindPoint;
273 VkPipelineLayout layout;
274 uint32_t firstSet;
275 uint32_t descriptorSetCount;
276 const VkDescriptorSet* pDescriptorSets;
277 VkDescriptorSet stack_pDescriptorSets[MAX_STACK_ITEMS];
278 uint32_t dynamicOffsetCount;
279 const uint32_t* pDynamicOffsets;
280 uint32_t stack_pDynamicOffsets[MAX_STACK_ITEMS];
281 memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
282 sizeof(VkPipelineBindPoint));
283 *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
284 uint64_t cgen_var_0;
285 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
286 *readStreamPtrPtr += 1 * 8;
287 *(VkPipelineLayout*)&layout =
288 (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
289 memcpy((uint32_t*)&firstSet, *readStreamPtrPtr, sizeof(uint32_t));
290 *readStreamPtrPtr += sizeof(uint32_t);
291 memcpy((uint32_t*)&descriptorSetCount, *readStreamPtrPtr, sizeof(uint32_t));
292 *readStreamPtrPtr += sizeof(uint32_t);
293 if (((descriptorSetCount)) <= MAX_STACK_ITEMS) {
294 pDescriptorSets = (VkDescriptorSet*)stack_pDescriptorSets;
295 } else {
296 readStream->alloc((void**)&pDescriptorSets,
297 ((descriptorSetCount)) * sizeof(const VkDescriptorSet));
298 }
299 if (((descriptorSetCount))) {
300 uint8_t* cgen_var_1_ptr = (uint8_t*)(*readStreamPtrPtr);
301 *readStreamPtrPtr += 8 * ((descriptorSetCount));
302 for (uint32_t k = 0; k < ((descriptorSetCount)); ++k) {
303 uint64_t tmpval;
304 memcpy(&tmpval, cgen_var_1_ptr + k * 8, sizeof(uint64_t));
305 *(((VkDescriptorSet*)pDescriptorSets) + k) =
306 (VkDescriptorSet)unbox_VkDescriptorSet((VkDescriptorSet)tmpval);
307 }
308 }
309 memcpy((uint32_t*)&dynamicOffsetCount, *readStreamPtrPtr, sizeof(uint32_t));
310 *readStreamPtrPtr += sizeof(uint32_t);
311 if (((dynamicOffsetCount)) <= MAX_STACK_ITEMS) {
312 pDynamicOffsets = (uint32_t*)stack_pDynamicOffsets;
313 } else {
314 readStream->alloc((void**)&pDynamicOffsets,
315 ((dynamicOffsetCount)) * sizeof(const uint32_t));
316 }
317 memcpy((uint32_t*)pDynamicOffsets, *readStreamPtrPtr,
318 ((dynamicOffsetCount)) * sizeof(const uint32_t));
319 *readStreamPtrPtr += ((dynamicOffsetCount)) * sizeof(const uint32_t);
320 this->on_vkCmdBindDescriptorSets(pool, (VkCommandBuffer)(boxed_dispatchHandle),
321 pipelineBindPoint, layout, firstSet,
322 descriptorSetCount, pDescriptorSets,
323 dynamicOffsetCount, pDynamicOffsets);
324 android::base::endTrace();
325 break;
326 }
327 case OP_vkCmdBindIndexBuffer: {
328 android::base::beginTrace("vkCmdBindIndexBuffer subdecode");
329 VkBuffer buffer;
330 VkDeviceSize offset;
331 VkIndexType indexType;
332 uint64_t cgen_var_0;
333 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
334 *readStreamPtrPtr += 1 * 8;
335 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
336 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
337 *readStreamPtrPtr += sizeof(VkDeviceSize);
338 memcpy((VkIndexType*)&indexType, *readStreamPtrPtr, sizeof(VkIndexType));
339 *readStreamPtrPtr += sizeof(VkIndexType);
340 vk->vkCmdBindIndexBuffer((VkCommandBuffer)dispatchHandle, buffer, offset,
341 indexType);
342 android::base::endTrace();
343 break;
344 }
345 case OP_vkCmdBindVertexBuffers: {
346 android::base::beginTrace("vkCmdBindVertexBuffers subdecode");
347 uint32_t firstBinding;
348 uint32_t bindingCount;
349 const VkBuffer* pBuffers;
350 VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
351 const VkDeviceSize* pOffsets;
352 VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
353 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
354 *readStreamPtrPtr += sizeof(uint32_t);
355 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
356 *readStreamPtrPtr += sizeof(uint32_t);
357 if (((bindingCount)) <= MAX_STACK_ITEMS) {
358 pBuffers = (VkBuffer*)stack_pBuffers;
359 } else {
360 readStream->alloc((void**)&pBuffers, ((bindingCount)) * sizeof(const VkBuffer));
361 }
362 if (((bindingCount))) {
363 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
364 *readStreamPtrPtr += 8 * ((bindingCount));
365 for (uint32_t k = 0; k < ((bindingCount)); ++k) {
366 uint64_t tmpval;
367 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
368 *(((VkBuffer*)pBuffers) + k) = (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval);
369 }
370 }
371 if (((bindingCount)) <= MAX_STACK_ITEMS) {
372 pOffsets = (VkDeviceSize*)stack_pOffsets;
373 } else {
374 readStream->alloc((void**)&pOffsets,
375 ((bindingCount)) * sizeof(const VkDeviceSize));
376 }
377 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
378 ((bindingCount)) * sizeof(const VkDeviceSize));
379 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
380 vk->vkCmdBindVertexBuffers((VkCommandBuffer)dispatchHandle, firstBinding,
381 bindingCount, pBuffers, pOffsets);
382 android::base::endTrace();
383 break;
384 }
385 case OP_vkCmdDraw: {
386 android::base::beginTrace("vkCmdDraw subdecode");
387 uint32_t vertexCount;
388 uint32_t instanceCount;
389 uint32_t firstVertex;
390 uint32_t firstInstance;
391 memcpy((uint32_t*)&vertexCount, *readStreamPtrPtr, sizeof(uint32_t));
392 *readStreamPtrPtr += sizeof(uint32_t);
393 memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
394 *readStreamPtrPtr += sizeof(uint32_t);
395 memcpy((uint32_t*)&firstVertex, *readStreamPtrPtr, sizeof(uint32_t));
396 *readStreamPtrPtr += sizeof(uint32_t);
397 memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
398 *readStreamPtrPtr += sizeof(uint32_t);
399 vk->vkCmdDraw((VkCommandBuffer)dispatchHandle, vertexCount, instanceCount,
400 firstVertex, firstInstance);
401 android::base::endTrace();
402 break;
403 }
404 case OP_vkCmdDrawIndexed: {
405 android::base::beginTrace("vkCmdDrawIndexed subdecode");
406 uint32_t indexCount;
407 uint32_t instanceCount;
408 uint32_t firstIndex;
409 int32_t vertexOffset;
410 uint32_t firstInstance;
411 memcpy((uint32_t*)&indexCount, *readStreamPtrPtr, sizeof(uint32_t));
412 *readStreamPtrPtr += sizeof(uint32_t);
413 memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
414 *readStreamPtrPtr += sizeof(uint32_t);
415 memcpy((uint32_t*)&firstIndex, *readStreamPtrPtr, sizeof(uint32_t));
416 *readStreamPtrPtr += sizeof(uint32_t);
417 memcpy((int32_t*)&vertexOffset, *readStreamPtrPtr, sizeof(int32_t));
418 *readStreamPtrPtr += sizeof(int32_t);
419 memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
420 *readStreamPtrPtr += sizeof(uint32_t);
421 vk->vkCmdDrawIndexed((VkCommandBuffer)dispatchHandle, indexCount, instanceCount,
422 firstIndex, vertexOffset, firstInstance);
423 android::base::endTrace();
424 break;
425 }
426 case OP_vkCmdDrawIndirect: {
427 android::base::beginTrace("vkCmdDrawIndirect subdecode");
428 VkBuffer buffer;
429 VkDeviceSize offset;
430 uint32_t drawCount;
431 uint32_t stride;
432 uint64_t cgen_var_0;
433 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
434 *readStreamPtrPtr += 1 * 8;
435 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
436 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
437 *readStreamPtrPtr += sizeof(VkDeviceSize);
438 memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
439 *readStreamPtrPtr += sizeof(uint32_t);
440 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
441 *readStreamPtrPtr += sizeof(uint32_t);
442 vk->vkCmdDrawIndirect((VkCommandBuffer)dispatchHandle, buffer, offset, drawCount,
443 stride);
444 android::base::endTrace();
445 break;
446 }
447 case OP_vkCmdDrawIndexedIndirect: {
448 android::base::beginTrace("vkCmdDrawIndexedIndirect subdecode");
449 VkBuffer buffer;
450 VkDeviceSize offset;
451 uint32_t drawCount;
452 uint32_t stride;
453 uint64_t cgen_var_0;
454 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
455 *readStreamPtrPtr += 1 * 8;
456 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
457 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
458 *readStreamPtrPtr += sizeof(VkDeviceSize);
459 memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
460 *readStreamPtrPtr += sizeof(uint32_t);
461 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
462 *readStreamPtrPtr += sizeof(uint32_t);
463 vk->vkCmdDrawIndexedIndirect((VkCommandBuffer)dispatchHandle, buffer, offset,
464 drawCount, stride);
465 android::base::endTrace();
466 break;
467 }
468 case OP_vkCmdDispatch: {
469 android::base::beginTrace("vkCmdDispatch subdecode");
470 uint32_t groupCountX;
471 uint32_t groupCountY;
472 uint32_t groupCountZ;
473 memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
474 *readStreamPtrPtr += sizeof(uint32_t);
475 memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
476 *readStreamPtrPtr += sizeof(uint32_t);
477 memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
478 *readStreamPtrPtr += sizeof(uint32_t);
479 vk->vkCmdDispatch((VkCommandBuffer)dispatchHandle, groupCountX, groupCountY,
480 groupCountZ);
481 android::base::endTrace();
482 break;
483 }
484 case OP_vkCmdDispatchIndirect: {
485 android::base::beginTrace("vkCmdDispatchIndirect subdecode");
486 VkBuffer buffer;
487 VkDeviceSize offset;
488 uint64_t cgen_var_0;
489 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
490 *readStreamPtrPtr += 1 * 8;
491 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
492 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
493 *readStreamPtrPtr += sizeof(VkDeviceSize);
494 vk->vkCmdDispatchIndirect((VkCommandBuffer)dispatchHandle, buffer, offset);
495 android::base::endTrace();
496 break;
497 }
498 case OP_vkCmdCopyBuffer: {
499 android::base::beginTrace("vkCmdCopyBuffer subdecode");
500 VkBuffer srcBuffer;
501 VkBuffer dstBuffer;
502 uint32_t regionCount;
503 const VkBufferCopy* pRegions;
504 VkBufferCopy stack_pRegions[MAX_STACK_ITEMS];
505 uint64_t cgen_var_0;
506 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
507 *readStreamPtrPtr += 1 * 8;
508 *(VkBuffer*)&srcBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
509 uint64_t cgen_var_1;
510 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
511 *readStreamPtrPtr += 1 * 8;
512 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
513 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
514 *readStreamPtrPtr += sizeof(uint32_t);
515 if (((regionCount)) <= MAX_STACK_ITEMS) {
516 pRegions = (VkBufferCopy*)stack_pRegions;
517 } else {
518 readStream->alloc((void**)&pRegions,
519 ((regionCount)) * sizeof(const VkBufferCopy));
520 }
521 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
522 reservedunmarshal_VkBufferCopy(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
523 (VkBufferCopy*)(pRegions + i), readStreamPtrPtr);
524 }
525 if (pRegions) {
526 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
527 transform_tohost_VkBufferCopy(globalstate, (VkBufferCopy*)(pRegions + i));
528 }
529 }
530 vk->vkCmdCopyBuffer((VkCommandBuffer)dispatchHandle, srcBuffer, dstBuffer,
531 regionCount, pRegions);
532 android::base::endTrace();
533 break;
534 }
535 case OP_vkCmdCopyImage: {
536 android::base::beginTrace("vkCmdCopyImage subdecode");
537 VkImage srcImage;
538 VkImageLayout srcImageLayout;
539 VkImage dstImage;
540 VkImageLayout dstImageLayout;
541 uint32_t regionCount;
542 const VkImageCopy* pRegions;
543 VkImageCopy stack_pRegions[MAX_STACK_ITEMS];
544 uint64_t cgen_var_0;
545 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
546 *readStreamPtrPtr += 1 * 8;
547 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
548 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
549 *readStreamPtrPtr += sizeof(VkImageLayout);
550 uint64_t cgen_var_1;
551 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
552 *readStreamPtrPtr += 1 * 8;
553 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
554 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
555 *readStreamPtrPtr += sizeof(VkImageLayout);
556 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
557 *readStreamPtrPtr += sizeof(uint32_t);
558 if (((regionCount)) <= MAX_STACK_ITEMS) {
559 pRegions = (VkImageCopy*)stack_pRegions;
560 } else {
561 readStream->alloc((void**)&pRegions,
562 ((regionCount)) * sizeof(const VkImageCopy));
563 }
564 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
565 reservedunmarshal_VkImageCopy(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
566 (VkImageCopy*)(pRegions + i), readStreamPtrPtr);
567 }
568 if (pRegions) {
569 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
570 transform_tohost_VkImageCopy(globalstate, (VkImageCopy*)(pRegions + i));
571 }
572 }
573 this->on_vkCmdCopyImage(pool, (VkCommandBuffer)(boxed_dispatchHandle), srcImage,
574 srcImageLayout, dstImage, dstImageLayout, regionCount,
575 pRegions);
576 android::base::endTrace();
577 break;
578 }
579 case OP_vkCmdBlitImage: {
580 android::base::beginTrace("vkCmdBlitImage subdecode");
581 VkImage srcImage;
582 VkImageLayout srcImageLayout;
583 VkImage dstImage;
584 VkImageLayout dstImageLayout;
585 uint32_t regionCount;
586 const VkImageBlit* pRegions;
587 VkImageBlit stack_pRegions[MAX_STACK_ITEMS];
588 VkFilter filter;
589 uint64_t cgen_var_0;
590 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
591 *readStreamPtrPtr += 1 * 8;
592 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
593 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
594 *readStreamPtrPtr += sizeof(VkImageLayout);
595 uint64_t cgen_var_1;
596 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
597 *readStreamPtrPtr += 1 * 8;
598 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
599 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
600 *readStreamPtrPtr += sizeof(VkImageLayout);
601 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
602 *readStreamPtrPtr += sizeof(uint32_t);
603 if (((regionCount)) <= MAX_STACK_ITEMS) {
604 pRegions = (VkImageBlit*)stack_pRegions;
605 } else {
606 readStream->alloc((void**)&pRegions,
607 ((regionCount)) * sizeof(const VkImageBlit));
608 }
609 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
610 reservedunmarshal_VkImageBlit(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
611 (VkImageBlit*)(pRegions + i), readStreamPtrPtr);
612 }
613 memcpy((VkFilter*)&filter, *readStreamPtrPtr, sizeof(VkFilter));
614 *readStreamPtrPtr += sizeof(VkFilter);
615 if (pRegions) {
616 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
617 transform_tohost_VkImageBlit(globalstate, (VkImageBlit*)(pRegions + i));
618 }
619 }
620 vk->vkCmdBlitImage((VkCommandBuffer)dispatchHandle, srcImage, srcImageLayout,
621 dstImage, dstImageLayout, regionCount, pRegions, filter);
622 android::base::endTrace();
623 break;
624 }
625 case OP_vkCmdCopyBufferToImage: {
626 android::base::beginTrace("vkCmdCopyBufferToImage subdecode");
627 VkBuffer srcBuffer;
628 VkImage dstImage;
629 VkImageLayout dstImageLayout;
630 uint32_t regionCount;
631 const VkBufferImageCopy* pRegions;
632 VkBufferImageCopy stack_pRegions[MAX_STACK_ITEMS];
633 uint64_t cgen_var_0;
634 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
635 *readStreamPtrPtr += 1 * 8;
636 *(VkBuffer*)&srcBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
637 uint64_t cgen_var_1;
638 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
639 *readStreamPtrPtr += 1 * 8;
640 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
641 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
642 *readStreamPtrPtr += sizeof(VkImageLayout);
643 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
644 *readStreamPtrPtr += sizeof(uint32_t);
645 if (((regionCount)) <= MAX_STACK_ITEMS) {
646 pRegions = (VkBufferImageCopy*)stack_pRegions;
647 } else {
648 readStream->alloc((void**)&pRegions,
649 ((regionCount)) * sizeof(const VkBufferImageCopy));
650 }
651 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
652 reservedunmarshal_VkBufferImageCopy(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
653 (VkBufferImageCopy*)(pRegions + i),
654 readStreamPtrPtr);
655 }
656 if (pRegions) {
657 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
658 transform_tohost_VkBufferImageCopy(globalstate,
659 (VkBufferImageCopy*)(pRegions + i));
660 }
661 }
662 this->on_vkCmdCopyBufferToImage(pool, (VkCommandBuffer)(boxed_dispatchHandle),
663 srcBuffer, dstImage, dstImageLayout, regionCount,
664 pRegions, context);
665 android::base::endTrace();
666 break;
667 }
668 case OP_vkCmdCopyImageToBuffer: {
669 android::base::beginTrace("vkCmdCopyImageToBuffer subdecode");
670 VkImage srcImage;
671 VkImageLayout srcImageLayout;
672 VkBuffer dstBuffer;
673 uint32_t regionCount;
674 const VkBufferImageCopy* pRegions;
675 VkBufferImageCopy stack_pRegions[MAX_STACK_ITEMS];
676 uint64_t cgen_var_0;
677 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
678 *readStreamPtrPtr += 1 * 8;
679 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
680 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
681 *readStreamPtrPtr += sizeof(VkImageLayout);
682 uint64_t cgen_var_1;
683 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
684 *readStreamPtrPtr += 1 * 8;
685 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
686 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
687 *readStreamPtrPtr += sizeof(uint32_t);
688 if (((regionCount)) <= MAX_STACK_ITEMS) {
689 pRegions = (VkBufferImageCopy*)stack_pRegions;
690 } else {
691 readStream->alloc((void**)&pRegions,
692 ((regionCount)) * sizeof(const VkBufferImageCopy));
693 }
694 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
695 reservedunmarshal_VkBufferImageCopy(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
696 (VkBufferImageCopy*)(pRegions + i),
697 readStreamPtrPtr);
698 }
699 if (pRegions) {
700 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
701 transform_tohost_VkBufferImageCopy(globalstate,
702 (VkBufferImageCopy*)(pRegions + i));
703 }
704 }
705 this->on_vkCmdCopyImageToBuffer(pool, (VkCommandBuffer)(boxed_dispatchHandle),
706 srcImage, srcImageLayout, dstBuffer, regionCount,
707 pRegions);
708 android::base::endTrace();
709 break;
710 }
711 case OP_vkCmdUpdateBuffer: {
712 android::base::beginTrace("vkCmdUpdateBuffer subdecode");
713 VkBuffer dstBuffer;
714 VkDeviceSize dstOffset;
715 VkDeviceSize dataSize;
716 const void* pData;
717 uint8_t* stack_pData[MAX_STACK_ITEMS];
718 uint64_t cgen_var_0;
719 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
720 *readStreamPtrPtr += 1 * 8;
721 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
722 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
723 *readStreamPtrPtr += sizeof(VkDeviceSize);
724 memcpy((VkDeviceSize*)&dataSize, *readStreamPtrPtr, sizeof(VkDeviceSize));
725 *readStreamPtrPtr += sizeof(VkDeviceSize);
726 if (((dataSize)) <= MAX_STACK_ITEMS) {
727 pData = (void*)stack_pData;
728 } else {
729 readStream->alloc((void**)&pData, ((dataSize)) * sizeof(const uint8_t));
730 }
731 memcpy((void*)pData, *readStreamPtrPtr, ((dataSize)) * sizeof(const uint8_t));
732 *readStreamPtrPtr += ((dataSize)) * sizeof(const uint8_t);
733 vk->vkCmdUpdateBuffer((VkCommandBuffer)dispatchHandle, dstBuffer, dstOffset,
734 dataSize, pData);
735 android::base::endTrace();
736 break;
737 }
738 case OP_vkCmdFillBuffer: {
739 android::base::beginTrace("vkCmdFillBuffer subdecode");
740 VkBuffer dstBuffer;
741 VkDeviceSize dstOffset;
742 VkDeviceSize size;
743 uint32_t data;
744 uint64_t cgen_var_0;
745 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
746 *readStreamPtrPtr += 1 * 8;
747 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
748 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
749 *readStreamPtrPtr += sizeof(VkDeviceSize);
750 memcpy((VkDeviceSize*)&size, *readStreamPtrPtr, sizeof(VkDeviceSize));
751 *readStreamPtrPtr += sizeof(VkDeviceSize);
752 memcpy((uint32_t*)&data, *readStreamPtrPtr, sizeof(uint32_t));
753 *readStreamPtrPtr += sizeof(uint32_t);
754 vk->vkCmdFillBuffer((VkCommandBuffer)dispatchHandle, dstBuffer, dstOffset, size,
755 data);
756 android::base::endTrace();
757 break;
758 }
759 case OP_vkCmdClearColorImage: {
760 android::base::beginTrace("vkCmdClearColorImage subdecode");
761 VkImage image;
762 VkImageLayout imageLayout;
763 const VkClearColorValue* pColor;
764 VkClearColorValue stack_pColor[1];
765 uint32_t rangeCount;
766 const VkImageSubresourceRange* pRanges;
767 VkImageSubresourceRange stack_pRanges[MAX_STACK_ITEMS];
768 uint64_t cgen_var_0;
769 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
770 *readStreamPtrPtr += 1 * 8;
771 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
772 memcpy((VkImageLayout*)&imageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
773 *readStreamPtrPtr += sizeof(VkImageLayout);
774 pColor = (VkClearColorValue*)stack_pColor;
775 reservedunmarshal_VkClearColorValue(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
776 (VkClearColorValue*)(pColor), readStreamPtrPtr);
777 memcpy((uint32_t*)&rangeCount, *readStreamPtrPtr, sizeof(uint32_t));
778 *readStreamPtrPtr += sizeof(uint32_t);
779 if (((rangeCount)) <= MAX_STACK_ITEMS) {
780 pRanges = (VkImageSubresourceRange*)stack_pRanges;
781 } else {
782 readStream->alloc((void**)&pRanges,
783 ((rangeCount)) * sizeof(const VkImageSubresourceRange));
784 }
785 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
786 reservedunmarshal_VkImageSubresourceRange(
787 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
788 (VkImageSubresourceRange*)(pRanges + i), readStreamPtrPtr);
789 }
790 if (pColor) {
791 transform_tohost_VkClearColorValue(globalstate, (VkClearColorValue*)(pColor));
792 }
793 if (pRanges) {
794 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
795 transform_tohost_VkImageSubresourceRange(
796 globalstate, (VkImageSubresourceRange*)(pRanges + i));
797 }
798 }
799 vk->vkCmdClearColorImage((VkCommandBuffer)dispatchHandle, image, imageLayout,
800 pColor, rangeCount, pRanges);
801 android::base::endTrace();
802 break;
803 }
804 case OP_vkCmdClearDepthStencilImage: {
805 android::base::beginTrace("vkCmdClearDepthStencilImage subdecode");
806 VkImage image;
807 VkImageLayout imageLayout;
808 const VkClearDepthStencilValue* pDepthStencil;
809 VkClearDepthStencilValue stack_pDepthStencil[1];
810 uint32_t rangeCount;
811 const VkImageSubresourceRange* pRanges;
812 VkImageSubresourceRange stack_pRanges[MAX_STACK_ITEMS];
813 uint64_t cgen_var_0;
814 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
815 *readStreamPtrPtr += 1 * 8;
816 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
817 memcpy((VkImageLayout*)&imageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
818 *readStreamPtrPtr += sizeof(VkImageLayout);
819 pDepthStencil = (VkClearDepthStencilValue*)stack_pDepthStencil;
820 reservedunmarshal_VkClearDepthStencilValue(
821 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
822 (VkClearDepthStencilValue*)(pDepthStencil), readStreamPtrPtr);
823 memcpy((uint32_t*)&rangeCount, *readStreamPtrPtr, sizeof(uint32_t));
824 *readStreamPtrPtr += sizeof(uint32_t);
825 if (((rangeCount)) <= MAX_STACK_ITEMS) {
826 pRanges = (VkImageSubresourceRange*)stack_pRanges;
827 } else {
828 readStream->alloc((void**)&pRanges,
829 ((rangeCount)) * sizeof(const VkImageSubresourceRange));
830 }
831 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
832 reservedunmarshal_VkImageSubresourceRange(
833 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
834 (VkImageSubresourceRange*)(pRanges + i), readStreamPtrPtr);
835 }
836 if (pDepthStencil) {
837 transform_tohost_VkClearDepthStencilValue(
838 globalstate, (VkClearDepthStencilValue*)(pDepthStencil));
839 }
840 if (pRanges) {
841 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
842 transform_tohost_VkImageSubresourceRange(
843 globalstate, (VkImageSubresourceRange*)(pRanges + i));
844 }
845 }
846 vk->vkCmdClearDepthStencilImage((VkCommandBuffer)dispatchHandle, image, imageLayout,
847 pDepthStencil, rangeCount, pRanges);
848 android::base::endTrace();
849 break;
850 }
851 case OP_vkCmdClearAttachments: {
852 android::base::beginTrace("vkCmdClearAttachments subdecode");
853 uint32_t attachmentCount;
854 const VkClearAttachment* pAttachments;
855 VkClearAttachment stack_pAttachments[MAX_STACK_ITEMS];
856 uint32_t rectCount;
857 const VkClearRect* pRects;
858 VkClearRect stack_pRects[MAX_STACK_ITEMS];
859 memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
860 *readStreamPtrPtr += sizeof(uint32_t);
861 if (((attachmentCount)) <= MAX_STACK_ITEMS) {
862 pAttachments = (VkClearAttachment*)stack_pAttachments;
863 } else {
864 readStream->alloc((void**)&pAttachments,
865 ((attachmentCount)) * sizeof(const VkClearAttachment));
866 }
867 for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
868 reservedunmarshal_VkClearAttachment(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
869 (VkClearAttachment*)(pAttachments + i),
870 readStreamPtrPtr);
871 }
872 memcpy((uint32_t*)&rectCount, *readStreamPtrPtr, sizeof(uint32_t));
873 *readStreamPtrPtr += sizeof(uint32_t);
874 if (((rectCount)) <= MAX_STACK_ITEMS) {
875 pRects = (VkClearRect*)stack_pRects;
876 } else {
877 readStream->alloc((void**)&pRects, ((rectCount)) * sizeof(const VkClearRect));
878 }
879 for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i) {
880 reservedunmarshal_VkClearRect(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
881 (VkClearRect*)(pRects + i), readStreamPtrPtr);
882 }
883 if (pAttachments) {
884 for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
885 transform_tohost_VkClearAttachment(globalstate,
886 (VkClearAttachment*)(pAttachments + i));
887 }
888 }
889 if (pRects) {
890 for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i) {
891 transform_tohost_VkClearRect(globalstate, (VkClearRect*)(pRects + i));
892 }
893 }
894 vk->vkCmdClearAttachments((VkCommandBuffer)dispatchHandle, attachmentCount,
895 pAttachments, rectCount, pRects);
896 android::base::endTrace();
897 break;
898 }
899 case OP_vkCmdResolveImage: {
900 android::base::beginTrace("vkCmdResolveImage subdecode");
901 VkImage srcImage;
902 VkImageLayout srcImageLayout;
903 VkImage dstImage;
904 VkImageLayout dstImageLayout;
905 uint32_t regionCount;
906 const VkImageResolve* pRegions;
907 VkImageResolve stack_pRegions[MAX_STACK_ITEMS];
908 uint64_t cgen_var_0;
909 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
910 *readStreamPtrPtr += 1 * 8;
911 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
912 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
913 *readStreamPtrPtr += sizeof(VkImageLayout);
914 uint64_t cgen_var_1;
915 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
916 *readStreamPtrPtr += 1 * 8;
917 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
918 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
919 *readStreamPtrPtr += sizeof(VkImageLayout);
920 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
921 *readStreamPtrPtr += sizeof(uint32_t);
922 if (((regionCount)) <= MAX_STACK_ITEMS) {
923 pRegions = (VkImageResolve*)stack_pRegions;
924 } else {
925 readStream->alloc((void**)&pRegions,
926 ((regionCount)) * sizeof(const VkImageResolve));
927 }
928 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
929 reservedunmarshal_VkImageResolve(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
930 (VkImageResolve*)(pRegions + i),
931 readStreamPtrPtr);
932 }
933 if (pRegions) {
934 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
935 transform_tohost_VkImageResolve(globalstate,
936 (VkImageResolve*)(pRegions + i));
937 }
938 }
939 vk->vkCmdResolveImage((VkCommandBuffer)dispatchHandle, srcImage, srcImageLayout,
940 dstImage, dstImageLayout, regionCount, pRegions);
941 android::base::endTrace();
942 break;
943 }
944 case OP_vkCmdSetEvent: {
945 android::base::beginTrace("vkCmdSetEvent subdecode");
946 VkEvent event;
947 VkPipelineStageFlags stageMask;
948 uint64_t cgen_var_0;
949 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
950 *readStreamPtrPtr += 1 * 8;
951 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
952 memcpy((VkPipelineStageFlags*)&stageMask, *readStreamPtrPtr,
953 sizeof(VkPipelineStageFlags));
954 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
955 vk->vkCmdSetEvent((VkCommandBuffer)dispatchHandle, event, stageMask);
956 android::base::endTrace();
957 break;
958 }
959 case OP_vkCmdResetEvent: {
960 android::base::beginTrace("vkCmdResetEvent subdecode");
961 VkEvent event;
962 VkPipelineStageFlags stageMask;
963 uint64_t cgen_var_0;
964 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
965 *readStreamPtrPtr += 1 * 8;
966 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
967 memcpy((VkPipelineStageFlags*)&stageMask, *readStreamPtrPtr,
968 sizeof(VkPipelineStageFlags));
969 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
970 vk->vkCmdResetEvent((VkCommandBuffer)dispatchHandle, event, stageMask);
971 android::base::endTrace();
972 break;
973 }
974 case OP_vkCmdWaitEvents: {
975 android::base::beginTrace("vkCmdWaitEvents subdecode");
976 uint32_t eventCount;
977 const VkEvent* pEvents;
978 VkEvent stack_pEvents[MAX_STACK_ITEMS];
979 VkPipelineStageFlags srcStageMask;
980 VkPipelineStageFlags dstStageMask;
981 uint32_t memoryBarrierCount;
982 const VkMemoryBarrier* pMemoryBarriers;
983 VkMemoryBarrier stack_pMemoryBarriers[MAX_STACK_ITEMS];
984 uint32_t bufferMemoryBarrierCount;
985 const VkBufferMemoryBarrier* pBufferMemoryBarriers;
986 VkBufferMemoryBarrier stack_pBufferMemoryBarriers[MAX_STACK_ITEMS];
987 uint32_t imageMemoryBarrierCount;
988 const VkImageMemoryBarrier* pImageMemoryBarriers;
989 VkImageMemoryBarrier stack_pImageMemoryBarriers[MAX_STACK_ITEMS];
990 memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
991 *readStreamPtrPtr += sizeof(uint32_t);
992 if (((eventCount)) <= MAX_STACK_ITEMS) {
993 pEvents = (VkEvent*)stack_pEvents;
994 } else {
995 readStream->alloc((void**)&pEvents, ((eventCount)) * sizeof(const VkEvent));
996 }
997 if (((eventCount))) {
998 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
999 *readStreamPtrPtr += 8 * ((eventCount));
1000 for (uint32_t k = 0; k < ((eventCount)); ++k) {
1001 uint64_t tmpval;
1002 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
1003 *(((VkEvent*)pEvents) + k) = (VkEvent)unbox_VkEvent((VkEvent)tmpval);
1004 }
1005 }
1006 memcpy((VkPipelineStageFlags*)&srcStageMask, *readStreamPtrPtr,
1007 sizeof(VkPipelineStageFlags));
1008 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1009 memcpy((VkPipelineStageFlags*)&dstStageMask, *readStreamPtrPtr,
1010 sizeof(VkPipelineStageFlags));
1011 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1012 memcpy((uint32_t*)&memoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1013 *readStreamPtrPtr += sizeof(uint32_t);
1014 if (((memoryBarrierCount)) <= MAX_STACK_ITEMS) {
1015 pMemoryBarriers = (VkMemoryBarrier*)stack_pMemoryBarriers;
1016 } else {
1017 readStream->alloc((void**)&pMemoryBarriers,
1018 ((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
1019 }
1020 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
1021 reservedunmarshal_VkMemoryBarrier(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1022 (VkMemoryBarrier*)(pMemoryBarriers + i),
1023 readStreamPtrPtr);
1024 }
1025 memcpy((uint32_t*)&bufferMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1026 *readStreamPtrPtr += sizeof(uint32_t);
1027 if (((bufferMemoryBarrierCount)) <= MAX_STACK_ITEMS) {
1028 pBufferMemoryBarriers = (VkBufferMemoryBarrier*)stack_pBufferMemoryBarriers;
1029 } else {
1030 readStream->alloc(
1031 (void**)&pBufferMemoryBarriers,
1032 ((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
1033 }
1034 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
1035 reservedunmarshal_VkBufferMemoryBarrier(
1036 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1037 (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i), readStreamPtrPtr);
1038 }
1039 memcpy((uint32_t*)&imageMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1040 *readStreamPtrPtr += sizeof(uint32_t);
1041 if (((imageMemoryBarrierCount)) <= MAX_STACK_ITEMS) {
1042 pImageMemoryBarriers = (VkImageMemoryBarrier*)stack_pImageMemoryBarriers;
1043 } else {
1044 readStream->alloc(
1045 (void**)&pImageMemoryBarriers,
1046 ((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
1047 }
1048 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
1049 reservedunmarshal_VkImageMemoryBarrier(
1050 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1051 (VkImageMemoryBarrier*)(pImageMemoryBarriers + i), readStreamPtrPtr);
1052 }
1053 if (pMemoryBarriers) {
1054 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
1055 transform_tohost_VkMemoryBarrier(globalstate,
1056 (VkMemoryBarrier*)(pMemoryBarriers + i));
1057 }
1058 }
1059 if (pBufferMemoryBarriers) {
1060 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
1061 transform_tohost_VkBufferMemoryBarrier(
1062 globalstate, (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i));
1063 }
1064 }
1065 if (pImageMemoryBarriers) {
1066 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
1067 transform_tohost_VkImageMemoryBarrier(
1068 globalstate, (VkImageMemoryBarrier*)(pImageMemoryBarriers + i));
1069 }
1070 }
1071 vk->vkCmdWaitEvents((VkCommandBuffer)dispatchHandle, eventCount, pEvents,
1072 srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers,
1073 bufferMemoryBarrierCount, pBufferMemoryBarriers,
1074 imageMemoryBarrierCount, pImageMemoryBarriers);
1075 android::base::endTrace();
1076 break;
1077 }
1078 case OP_vkCmdPipelineBarrier: {
1079 android::base::beginTrace("vkCmdPipelineBarrier subdecode");
1080 VkPipelineStageFlags srcStageMask;
1081 VkPipelineStageFlags dstStageMask;
1082 VkDependencyFlags dependencyFlags;
1083 uint32_t memoryBarrierCount;
1084 const VkMemoryBarrier* pMemoryBarriers;
1085 VkMemoryBarrier stack_pMemoryBarriers[MAX_STACK_ITEMS];
1086 uint32_t bufferMemoryBarrierCount;
1087 const VkBufferMemoryBarrier* pBufferMemoryBarriers;
1088 VkBufferMemoryBarrier stack_pBufferMemoryBarriers[MAX_STACK_ITEMS];
1089 uint32_t imageMemoryBarrierCount;
1090 const VkImageMemoryBarrier* pImageMemoryBarriers;
1091 VkImageMemoryBarrier stack_pImageMemoryBarriers[MAX_STACK_ITEMS];
1092 memcpy((VkPipelineStageFlags*)&srcStageMask, *readStreamPtrPtr,
1093 sizeof(VkPipelineStageFlags));
1094 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1095 memcpy((VkPipelineStageFlags*)&dstStageMask, *readStreamPtrPtr,
1096 sizeof(VkPipelineStageFlags));
1097 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1098 memcpy((VkDependencyFlags*)&dependencyFlags, *readStreamPtrPtr,
1099 sizeof(VkDependencyFlags));
1100 *readStreamPtrPtr += sizeof(VkDependencyFlags);
1101 memcpy((uint32_t*)&memoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1102 *readStreamPtrPtr += sizeof(uint32_t);
1103 if (((memoryBarrierCount)) <= MAX_STACK_ITEMS) {
1104 pMemoryBarriers = (VkMemoryBarrier*)stack_pMemoryBarriers;
1105 } else {
1106 readStream->alloc((void**)&pMemoryBarriers,
1107 ((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
1108 }
1109 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
1110 reservedunmarshal_VkMemoryBarrier(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1111 (VkMemoryBarrier*)(pMemoryBarriers + i),
1112 readStreamPtrPtr);
1113 }
1114 memcpy((uint32_t*)&bufferMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1115 *readStreamPtrPtr += sizeof(uint32_t);
1116 if (((bufferMemoryBarrierCount)) <= MAX_STACK_ITEMS) {
1117 pBufferMemoryBarriers = (VkBufferMemoryBarrier*)stack_pBufferMemoryBarriers;
1118 } else {
1119 readStream->alloc(
1120 (void**)&pBufferMemoryBarriers,
1121 ((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
1122 }
1123 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
1124 reservedunmarshal_VkBufferMemoryBarrier(
1125 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1126 (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i), readStreamPtrPtr);
1127 }
1128 memcpy((uint32_t*)&imageMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1129 *readStreamPtrPtr += sizeof(uint32_t);
1130 if (((imageMemoryBarrierCount)) <= MAX_STACK_ITEMS) {
1131 pImageMemoryBarriers = (VkImageMemoryBarrier*)stack_pImageMemoryBarriers;
1132 } else {
1133 readStream->alloc(
1134 (void**)&pImageMemoryBarriers,
1135 ((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
1136 }
1137 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
1138 reservedunmarshal_VkImageMemoryBarrier(
1139 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1140 (VkImageMemoryBarrier*)(pImageMemoryBarriers + i), readStreamPtrPtr);
1141 }
1142 if (pMemoryBarriers) {
1143 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
1144 transform_tohost_VkMemoryBarrier(globalstate,
1145 (VkMemoryBarrier*)(pMemoryBarriers + i));
1146 }
1147 }
1148 if (pBufferMemoryBarriers) {
1149 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
1150 transform_tohost_VkBufferMemoryBarrier(
1151 globalstate, (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i));
1152 }
1153 }
1154 if (pImageMemoryBarriers) {
1155 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
1156 transform_tohost_VkImageMemoryBarrier(
1157 globalstate, (VkImageMemoryBarrier*)(pImageMemoryBarriers + i));
1158 }
1159 }
1160 this->on_vkCmdPipelineBarrier(
1161 pool, (VkCommandBuffer)(boxed_dispatchHandle), srcStageMask, dstStageMask,
1162 dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
1163 pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1164 android::base::endTrace();
1165 break;
1166 }
1167 case OP_vkCmdBeginQuery: {
1168 android::base::beginTrace("vkCmdBeginQuery subdecode");
1169 VkQueryPool queryPool;
1170 uint32_t query;
1171 VkQueryControlFlags flags;
1172 uint64_t cgen_var_0;
1173 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1174 *readStreamPtrPtr += 1 * 8;
1175 *(VkQueryPool*)&queryPool =
1176 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1177 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
1178 *readStreamPtrPtr += sizeof(uint32_t);
1179 memcpy((VkQueryControlFlags*)&flags, *readStreamPtrPtr,
1180 sizeof(VkQueryControlFlags));
1181 *readStreamPtrPtr += sizeof(VkQueryControlFlags);
1182 vk->vkCmdBeginQuery((VkCommandBuffer)dispatchHandle, queryPool, query, flags);
1183 android::base::endTrace();
1184 break;
1185 }
1186 case OP_vkCmdEndQuery: {
1187 android::base::beginTrace("vkCmdEndQuery subdecode");
1188 VkQueryPool queryPool;
1189 uint32_t query;
1190 uint64_t cgen_var_0;
1191 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1192 *readStreamPtrPtr += 1 * 8;
1193 *(VkQueryPool*)&queryPool =
1194 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1195 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
1196 *readStreamPtrPtr += sizeof(uint32_t);
1197 vk->vkCmdEndQuery((VkCommandBuffer)dispatchHandle, queryPool, query);
1198 android::base::endTrace();
1199 break;
1200 }
1201 case OP_vkCmdResetQueryPool: {
1202 android::base::beginTrace("vkCmdResetQueryPool subdecode");
1203 VkQueryPool queryPool;
1204 uint32_t firstQuery;
1205 uint32_t queryCount;
1206 uint64_t cgen_var_0;
1207 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1208 *readStreamPtrPtr += 1 * 8;
1209 *(VkQueryPool*)&queryPool =
1210 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1211 memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
1212 *readStreamPtrPtr += sizeof(uint32_t);
1213 memcpy((uint32_t*)&queryCount, *readStreamPtrPtr, sizeof(uint32_t));
1214 *readStreamPtrPtr += sizeof(uint32_t);
1215 vk->vkCmdResetQueryPool((VkCommandBuffer)dispatchHandle, queryPool, firstQuery,
1216 queryCount);
1217 android::base::endTrace();
1218 break;
1219 }
1220 case OP_vkCmdWriteTimestamp: {
1221 android::base::beginTrace("vkCmdWriteTimestamp subdecode");
1222 VkPipelineStageFlagBits pipelineStage;
1223 VkQueryPool queryPool;
1224 uint32_t query;
1225 memcpy((VkPipelineStageFlagBits*)&pipelineStage, *readStreamPtrPtr,
1226 sizeof(VkPipelineStageFlagBits));
1227 *readStreamPtrPtr += sizeof(VkPipelineStageFlagBits);
1228 uint64_t cgen_var_0;
1229 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1230 *readStreamPtrPtr += 1 * 8;
1231 *(VkQueryPool*)&queryPool =
1232 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1233 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
1234 *readStreamPtrPtr += sizeof(uint32_t);
1235 vk->vkCmdWriteTimestamp((VkCommandBuffer)dispatchHandle, pipelineStage, queryPool,
1236 query);
1237 android::base::endTrace();
1238 break;
1239 }
1240 case OP_vkCmdCopyQueryPoolResults: {
1241 android::base::beginTrace("vkCmdCopyQueryPoolResults subdecode");
1242 VkQueryPool queryPool;
1243 uint32_t firstQuery;
1244 uint32_t queryCount;
1245 VkBuffer dstBuffer;
1246 VkDeviceSize dstOffset;
1247 VkDeviceSize stride;
1248 VkQueryResultFlags flags;
1249 uint64_t cgen_var_0;
1250 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1251 *readStreamPtrPtr += 1 * 8;
1252 *(VkQueryPool*)&queryPool =
1253 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1254 memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
1255 *readStreamPtrPtr += sizeof(uint32_t);
1256 memcpy((uint32_t*)&queryCount, *readStreamPtrPtr, sizeof(uint32_t));
1257 *readStreamPtrPtr += sizeof(uint32_t);
1258 uint64_t cgen_var_1;
1259 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1260 *readStreamPtrPtr += 1 * 8;
1261 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
1262 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1263 *readStreamPtrPtr += sizeof(VkDeviceSize);
1264 memcpy((VkDeviceSize*)&stride, *readStreamPtrPtr, sizeof(VkDeviceSize));
1265 *readStreamPtrPtr += sizeof(VkDeviceSize);
1266 memcpy((VkQueryResultFlags*)&flags, *readStreamPtrPtr, sizeof(VkQueryResultFlags));
1267 *readStreamPtrPtr += sizeof(VkQueryResultFlags);
1268 this->on_vkCmdCopyQueryPoolResults(pool, (VkCommandBuffer)(boxed_dispatchHandle),
1269 queryPool, firstQuery, queryCount, dstBuffer,
1270 dstOffset, stride, flags);
1271 android::base::endTrace();
1272 break;
1273 }
1274 case OP_vkCmdPushConstants: {
1275 android::base::beginTrace("vkCmdPushConstants subdecode");
1276 VkPipelineLayout layout;
1277 VkShaderStageFlags stageFlags;
1278 uint32_t offset;
1279 uint32_t size;
1280 const void* pValues;
1281 uint8_t* stack_pValues[MAX_STACK_ITEMS];
1282 uint64_t cgen_var_0;
1283 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1284 *readStreamPtrPtr += 1 * 8;
1285 *(VkPipelineLayout*)&layout =
1286 (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
1287 memcpy((VkShaderStageFlags*)&stageFlags, *readStreamPtrPtr,
1288 sizeof(VkShaderStageFlags));
1289 *readStreamPtrPtr += sizeof(VkShaderStageFlags);
1290 memcpy((uint32_t*)&offset, *readStreamPtrPtr, sizeof(uint32_t));
1291 *readStreamPtrPtr += sizeof(uint32_t);
1292 memcpy((uint32_t*)&size, *readStreamPtrPtr, sizeof(uint32_t));
1293 *readStreamPtrPtr += sizeof(uint32_t);
1294 if (((size)) <= MAX_STACK_ITEMS) {
1295 pValues = (void*)stack_pValues;
1296 } else {
1297 readStream->alloc((void**)&pValues, ((size)) * sizeof(const uint8_t));
1298 }
1299 memcpy((void*)pValues, *readStreamPtrPtr, ((size)) * sizeof(const uint8_t));
1300 *readStreamPtrPtr += ((size)) * sizeof(const uint8_t);
1301 vk->vkCmdPushConstants((VkCommandBuffer)dispatchHandle, layout, stageFlags, offset,
1302 size, pValues);
1303 android::base::endTrace();
1304 break;
1305 }
1306 case OP_vkCmdBeginRenderPass: {
1307 android::base::beginTrace("vkCmdBeginRenderPass subdecode");
1308 const VkRenderPassBeginInfo* pRenderPassBegin;
1309 VkRenderPassBeginInfo stack_pRenderPassBegin[1];
1310 VkSubpassContents contents;
1311 pRenderPassBegin = (VkRenderPassBeginInfo*)stack_pRenderPassBegin;
1312 reservedunmarshal_VkRenderPassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1313 (VkRenderPassBeginInfo*)(pRenderPassBegin),
1314 readStreamPtrPtr);
1315 memcpy((VkSubpassContents*)&contents, *readStreamPtrPtr, sizeof(VkSubpassContents));
1316 *readStreamPtrPtr += sizeof(VkSubpassContents);
1317 if (pRenderPassBegin) {
1318 transform_tohost_VkRenderPassBeginInfo(
1319 globalstate, (VkRenderPassBeginInfo*)(pRenderPassBegin));
1320 }
1321 vk->vkCmdBeginRenderPass((VkCommandBuffer)dispatchHandle, pRenderPassBegin,
1322 contents);
1323 android::base::endTrace();
1324 break;
1325 }
1326 case OP_vkCmdNextSubpass: {
1327 android::base::beginTrace("vkCmdNextSubpass subdecode");
1328 VkSubpassContents contents;
1329 memcpy((VkSubpassContents*)&contents, *readStreamPtrPtr, sizeof(VkSubpassContents));
1330 *readStreamPtrPtr += sizeof(VkSubpassContents);
1331 vk->vkCmdNextSubpass((VkCommandBuffer)dispatchHandle, contents);
1332 android::base::endTrace();
1333 break;
1334 }
1335 case OP_vkCmdEndRenderPass: {
1336 android::base::beginTrace("vkCmdEndRenderPass subdecode");
1337 vk->vkCmdEndRenderPass((VkCommandBuffer)dispatchHandle);
1338 android::base::endTrace();
1339 break;
1340 }
1341 case OP_vkCmdExecuteCommands: {
1342 android::base::beginTrace("vkCmdExecuteCommands subdecode");
1343 uint32_t commandBufferCount;
1344 const VkCommandBuffer* pCommandBuffers;
1345 VkCommandBuffer stack_pCommandBuffers[MAX_STACK_ITEMS];
1346 memcpy((uint32_t*)&commandBufferCount, *readStreamPtrPtr, sizeof(uint32_t));
1347 *readStreamPtrPtr += sizeof(uint32_t);
1348 if (((commandBufferCount)) <= MAX_STACK_ITEMS) {
1349 pCommandBuffers = (VkCommandBuffer*)stack_pCommandBuffers;
1350 } else {
1351 readStream->alloc((void**)&pCommandBuffers,
1352 ((commandBufferCount)) * sizeof(const VkCommandBuffer));
1353 }
1354 if (((commandBufferCount))) {
1355 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
1356 *readStreamPtrPtr += 8 * ((commandBufferCount));
1357 for (uint32_t k = 0; k < ((commandBufferCount)); ++k) {
1358 uint64_t tmpval;
1359 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
1360 *(((VkCommandBuffer*)pCommandBuffers) + k) =
1361 (VkCommandBuffer)unbox_VkCommandBuffer((VkCommandBuffer)tmpval);
1362 }
1363 }
1364 this->on_vkCmdExecuteCommands(pool, (VkCommandBuffer)(boxed_dispatchHandle),
1365 commandBufferCount, pCommandBuffers);
1366 android::base::endTrace();
1367 break;
1368 }
1369 #endif
1370 #ifdef VK_VERSION_1_1
1371 case OP_vkCmdSetDeviceMask: {
1372 android::base::beginTrace("vkCmdSetDeviceMask subdecode");
1373 uint32_t deviceMask;
1374 memcpy((uint32_t*)&deviceMask, *readStreamPtrPtr, sizeof(uint32_t));
1375 *readStreamPtrPtr += sizeof(uint32_t);
1376 vk->vkCmdSetDeviceMask((VkCommandBuffer)dispatchHandle, deviceMask);
1377 android::base::endTrace();
1378 break;
1379 }
1380 case OP_vkCmdDispatchBase: {
1381 android::base::beginTrace("vkCmdDispatchBase subdecode");
1382 uint32_t baseGroupX;
1383 uint32_t baseGroupY;
1384 uint32_t baseGroupZ;
1385 uint32_t groupCountX;
1386 uint32_t groupCountY;
1387 uint32_t groupCountZ;
1388 memcpy((uint32_t*)&baseGroupX, *readStreamPtrPtr, sizeof(uint32_t));
1389 *readStreamPtrPtr += sizeof(uint32_t);
1390 memcpy((uint32_t*)&baseGroupY, *readStreamPtrPtr, sizeof(uint32_t));
1391 *readStreamPtrPtr += sizeof(uint32_t);
1392 memcpy((uint32_t*)&baseGroupZ, *readStreamPtrPtr, sizeof(uint32_t));
1393 *readStreamPtrPtr += sizeof(uint32_t);
1394 memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
1395 *readStreamPtrPtr += sizeof(uint32_t);
1396 memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
1397 *readStreamPtrPtr += sizeof(uint32_t);
1398 memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
1399 *readStreamPtrPtr += sizeof(uint32_t);
1400 vk->vkCmdDispatchBase((VkCommandBuffer)dispatchHandle, baseGroupX, baseGroupY,
1401 baseGroupZ, groupCountX, groupCountY, groupCountZ);
1402 android::base::endTrace();
1403 break;
1404 }
1405 #endif
1406 #ifdef VK_VERSION_1_2
1407 case OP_vkCmdDrawIndirectCount: {
1408 android::base::beginTrace("vkCmdDrawIndirectCount subdecode");
1409 VkBuffer buffer;
1410 VkDeviceSize offset;
1411 VkBuffer countBuffer;
1412 VkDeviceSize countBufferOffset;
1413 uint32_t maxDrawCount;
1414 uint32_t stride;
1415 uint64_t cgen_var_0;
1416 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1417 *readStreamPtrPtr += 1 * 8;
1418 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
1419 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1420 *readStreamPtrPtr += sizeof(VkDeviceSize);
1421 uint64_t cgen_var_1;
1422 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1423 *readStreamPtrPtr += 1 * 8;
1424 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
1425 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1426 *readStreamPtrPtr += sizeof(VkDeviceSize);
1427 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
1428 *readStreamPtrPtr += sizeof(uint32_t);
1429 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
1430 *readStreamPtrPtr += sizeof(uint32_t);
1431 vk->vkCmdDrawIndirectCount((VkCommandBuffer)dispatchHandle, buffer, offset,
1432 countBuffer, countBufferOffset, maxDrawCount, stride);
1433 android::base::endTrace();
1434 break;
1435 }
1436 case OP_vkCmdDrawIndexedIndirectCount: {
1437 android::base::beginTrace("vkCmdDrawIndexedIndirectCount subdecode");
1438 VkBuffer buffer;
1439 VkDeviceSize offset;
1440 VkBuffer countBuffer;
1441 VkDeviceSize countBufferOffset;
1442 uint32_t maxDrawCount;
1443 uint32_t stride;
1444 uint64_t cgen_var_0;
1445 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1446 *readStreamPtrPtr += 1 * 8;
1447 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
1448 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1449 *readStreamPtrPtr += sizeof(VkDeviceSize);
1450 uint64_t cgen_var_1;
1451 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1452 *readStreamPtrPtr += 1 * 8;
1453 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
1454 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1455 *readStreamPtrPtr += sizeof(VkDeviceSize);
1456 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
1457 *readStreamPtrPtr += sizeof(uint32_t);
1458 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
1459 *readStreamPtrPtr += sizeof(uint32_t);
1460 vk->vkCmdDrawIndexedIndirectCount((VkCommandBuffer)dispatchHandle, buffer, offset,
1461 countBuffer, countBufferOffset, maxDrawCount,
1462 stride);
1463 android::base::endTrace();
1464 break;
1465 }
1466 case OP_vkCmdBeginRenderPass2: {
1467 android::base::beginTrace("vkCmdBeginRenderPass2 subdecode");
1468 const VkRenderPassBeginInfo* pRenderPassBegin;
1469 VkRenderPassBeginInfo stack_pRenderPassBegin[1];
1470 const VkSubpassBeginInfo* pSubpassBeginInfo;
1471 VkSubpassBeginInfo stack_pSubpassBeginInfo[1];
1472 pRenderPassBegin = (VkRenderPassBeginInfo*)stack_pRenderPassBegin;
1473 reservedunmarshal_VkRenderPassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1474 (VkRenderPassBeginInfo*)(pRenderPassBegin),
1475 readStreamPtrPtr);
1476 pSubpassBeginInfo = (VkSubpassBeginInfo*)stack_pSubpassBeginInfo;
1477 reservedunmarshal_VkSubpassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1478 (VkSubpassBeginInfo*)(pSubpassBeginInfo),
1479 readStreamPtrPtr);
1480 if (pRenderPassBegin) {
1481 transform_tohost_VkRenderPassBeginInfo(
1482 globalstate, (VkRenderPassBeginInfo*)(pRenderPassBegin));
1483 }
1484 if (pSubpassBeginInfo) {
1485 transform_tohost_VkSubpassBeginInfo(globalstate,
1486 (VkSubpassBeginInfo*)(pSubpassBeginInfo));
1487 }
1488 vk->vkCmdBeginRenderPass2((VkCommandBuffer)dispatchHandle, pRenderPassBegin,
1489 pSubpassBeginInfo);
1490 android::base::endTrace();
1491 break;
1492 }
1493 case OP_vkCmdNextSubpass2: {
1494 android::base::beginTrace("vkCmdNextSubpass2 subdecode");
1495 const VkSubpassBeginInfo* pSubpassBeginInfo;
1496 VkSubpassBeginInfo stack_pSubpassBeginInfo[1];
1497 const VkSubpassEndInfo* pSubpassEndInfo;
1498 VkSubpassEndInfo stack_pSubpassEndInfo[1];
1499 pSubpassBeginInfo = (VkSubpassBeginInfo*)stack_pSubpassBeginInfo;
1500 reservedunmarshal_VkSubpassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1501 (VkSubpassBeginInfo*)(pSubpassBeginInfo),
1502 readStreamPtrPtr);
1503 pSubpassEndInfo = (VkSubpassEndInfo*)stack_pSubpassEndInfo;
1504 reservedunmarshal_VkSubpassEndInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1505 (VkSubpassEndInfo*)(pSubpassEndInfo),
1506 readStreamPtrPtr);
1507 if (pSubpassBeginInfo) {
1508 transform_tohost_VkSubpassBeginInfo(globalstate,
1509 (VkSubpassBeginInfo*)(pSubpassBeginInfo));
1510 }
1511 if (pSubpassEndInfo) {
1512 transform_tohost_VkSubpassEndInfo(globalstate,
1513 (VkSubpassEndInfo*)(pSubpassEndInfo));
1514 }
1515 vk->vkCmdNextSubpass2((VkCommandBuffer)dispatchHandle, pSubpassBeginInfo,
1516 pSubpassEndInfo);
1517 android::base::endTrace();
1518 break;
1519 }
1520 case OP_vkCmdEndRenderPass2: {
1521 android::base::beginTrace("vkCmdEndRenderPass2 subdecode");
1522 const VkSubpassEndInfo* pSubpassEndInfo;
1523 VkSubpassEndInfo stack_pSubpassEndInfo[1];
1524 pSubpassEndInfo = (VkSubpassEndInfo*)stack_pSubpassEndInfo;
1525 reservedunmarshal_VkSubpassEndInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1526 (VkSubpassEndInfo*)(pSubpassEndInfo),
1527 readStreamPtrPtr);
1528 if (pSubpassEndInfo) {
1529 transform_tohost_VkSubpassEndInfo(globalstate,
1530 (VkSubpassEndInfo*)(pSubpassEndInfo));
1531 }
1532 vk->vkCmdEndRenderPass2((VkCommandBuffer)dispatchHandle, pSubpassEndInfo);
1533 android::base::endTrace();
1534 break;
1535 }
1536 #endif
1537 #ifdef VK_VERSION_1_3
1538 case OP_vkCmdSetEvent2: {
1539 android::base::beginTrace("vkCmdSetEvent2 subdecode");
1540 VkEvent event;
1541 const VkDependencyInfo* pDependencyInfo;
1542 VkDependencyInfo stack_pDependencyInfo[1];
1543 uint64_t cgen_var_0;
1544 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1545 *readStreamPtrPtr += 1 * 8;
1546 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
1547 pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
1548 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1549 (VkDependencyInfo*)(pDependencyInfo),
1550 readStreamPtrPtr);
1551 if (pDependencyInfo) {
1552 transform_tohost_VkDependencyInfo(globalstate,
1553 (VkDependencyInfo*)(pDependencyInfo));
1554 }
1555 vk->vkCmdSetEvent2((VkCommandBuffer)dispatchHandle, event, pDependencyInfo);
1556 android::base::endTrace();
1557 break;
1558 }
1559 case OP_vkCmdResetEvent2: {
1560 android::base::beginTrace("vkCmdResetEvent2 subdecode");
1561 VkEvent event;
1562 VkPipelineStageFlags2 stageMask;
1563 uint64_t cgen_var_0;
1564 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1565 *readStreamPtrPtr += 1 * 8;
1566 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
1567 memcpy((VkPipelineStageFlags2*)&stageMask, *readStreamPtrPtr,
1568 sizeof(VkPipelineStageFlags2));
1569 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
1570 vk->vkCmdResetEvent2((VkCommandBuffer)dispatchHandle, event, stageMask);
1571 android::base::endTrace();
1572 break;
1573 }
1574 case OP_vkCmdWaitEvents2: {
1575 android::base::beginTrace("vkCmdWaitEvents2 subdecode");
1576 uint32_t eventCount;
1577 const VkEvent* pEvents;
1578 VkEvent stack_pEvents[MAX_STACK_ITEMS];
1579 const VkDependencyInfo* pDependencyInfos;
1580 VkDependencyInfo stack_pDependencyInfos[MAX_STACK_ITEMS];
1581 memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
1582 *readStreamPtrPtr += sizeof(uint32_t);
1583 if (((eventCount)) <= MAX_STACK_ITEMS) {
1584 pEvents = (VkEvent*)stack_pEvents;
1585 } else {
1586 readStream->alloc((void**)&pEvents, ((eventCount)) * sizeof(const VkEvent));
1587 }
1588 if (((eventCount))) {
1589 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
1590 *readStreamPtrPtr += 8 * ((eventCount));
1591 for (uint32_t k = 0; k < ((eventCount)); ++k) {
1592 uint64_t tmpval;
1593 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
1594 *(((VkEvent*)pEvents) + k) = (VkEvent)unbox_VkEvent((VkEvent)tmpval);
1595 }
1596 }
1597 if (((eventCount)) <= MAX_STACK_ITEMS) {
1598 pDependencyInfos = (VkDependencyInfo*)stack_pDependencyInfos;
1599 } else {
1600 readStream->alloc((void**)&pDependencyInfos,
1601 ((eventCount)) * sizeof(const VkDependencyInfo));
1602 }
1603 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
1604 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1605 (VkDependencyInfo*)(pDependencyInfos + i),
1606 readStreamPtrPtr);
1607 }
1608 if (pDependencyInfos) {
1609 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
1610 transform_tohost_VkDependencyInfo(
1611 globalstate, (VkDependencyInfo*)(pDependencyInfos + i));
1612 }
1613 }
1614 vk->vkCmdWaitEvents2((VkCommandBuffer)dispatchHandle, eventCount, pEvents,
1615 pDependencyInfos);
1616 android::base::endTrace();
1617 break;
1618 }
1619 case OP_vkCmdPipelineBarrier2: {
1620 android::base::beginTrace("vkCmdPipelineBarrier2 subdecode");
1621 const VkDependencyInfo* pDependencyInfo;
1622 VkDependencyInfo stack_pDependencyInfo[1];
1623 pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
1624 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1625 (VkDependencyInfo*)(pDependencyInfo),
1626 readStreamPtrPtr);
1627 if (pDependencyInfo) {
1628 transform_tohost_VkDependencyInfo(globalstate,
1629 (VkDependencyInfo*)(pDependencyInfo));
1630 }
1631 vk->vkCmdPipelineBarrier2((VkCommandBuffer)dispatchHandle, pDependencyInfo);
1632 android::base::endTrace();
1633 break;
1634 }
1635 case OP_vkCmdWriteTimestamp2: {
1636 android::base::beginTrace("vkCmdWriteTimestamp2 subdecode");
1637 VkPipelineStageFlags2 stage;
1638 VkQueryPool queryPool;
1639 uint32_t query;
1640 memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
1641 sizeof(VkPipelineStageFlags2));
1642 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
1643 uint64_t cgen_var_0;
1644 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1645 *readStreamPtrPtr += 1 * 8;
1646 *(VkQueryPool*)&queryPool =
1647 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1648 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
1649 *readStreamPtrPtr += sizeof(uint32_t);
1650 vk->vkCmdWriteTimestamp2((VkCommandBuffer)dispatchHandle, stage, queryPool, query);
1651 android::base::endTrace();
1652 break;
1653 }
1654 case OP_vkCmdCopyBuffer2: {
1655 android::base::beginTrace("vkCmdCopyBuffer2 subdecode");
1656 const VkCopyBufferInfo2* pCopyBufferInfo;
1657 VkCopyBufferInfo2 stack_pCopyBufferInfo[1];
1658 pCopyBufferInfo = (VkCopyBufferInfo2*)stack_pCopyBufferInfo;
1659 reservedunmarshal_VkCopyBufferInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1660 (VkCopyBufferInfo2*)(pCopyBufferInfo),
1661 readStreamPtrPtr);
1662 if (pCopyBufferInfo) {
1663 transform_tohost_VkCopyBufferInfo2(globalstate,
1664 (VkCopyBufferInfo2*)(pCopyBufferInfo));
1665 }
1666 vk->vkCmdCopyBuffer2((VkCommandBuffer)dispatchHandle, pCopyBufferInfo);
1667 android::base::endTrace();
1668 break;
1669 }
1670 case OP_vkCmdCopyImage2: {
1671 android::base::beginTrace("vkCmdCopyImage2 subdecode");
1672 const VkCopyImageInfo2* pCopyImageInfo;
1673 VkCopyImageInfo2 stack_pCopyImageInfo[1];
1674 pCopyImageInfo = (VkCopyImageInfo2*)stack_pCopyImageInfo;
1675 reservedunmarshal_VkCopyImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1676 (VkCopyImageInfo2*)(pCopyImageInfo),
1677 readStreamPtrPtr);
1678 if (pCopyImageInfo) {
1679 transform_tohost_VkCopyImageInfo2(globalstate,
1680 (VkCopyImageInfo2*)(pCopyImageInfo));
1681 }
1682 vk->vkCmdCopyImage2((VkCommandBuffer)dispatchHandle, pCopyImageInfo);
1683 android::base::endTrace();
1684 break;
1685 }
1686 case OP_vkCmdCopyBufferToImage2: {
1687 android::base::beginTrace("vkCmdCopyBufferToImage2 subdecode");
1688 const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo;
1689 VkCopyBufferToImageInfo2 stack_pCopyBufferToImageInfo[1];
1690 pCopyBufferToImageInfo = (VkCopyBufferToImageInfo2*)stack_pCopyBufferToImageInfo;
1691 reservedunmarshal_VkCopyBufferToImageInfo2(
1692 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1693 (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo), readStreamPtrPtr);
1694 if (pCopyBufferToImageInfo) {
1695 transform_tohost_VkCopyBufferToImageInfo2(
1696 globalstate, (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo));
1697 }
1698 vk->vkCmdCopyBufferToImage2((VkCommandBuffer)dispatchHandle,
1699 pCopyBufferToImageInfo);
1700 android::base::endTrace();
1701 break;
1702 }
1703 case OP_vkCmdCopyImageToBuffer2: {
1704 android::base::beginTrace("vkCmdCopyImageToBuffer2 subdecode");
1705 const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo;
1706 VkCopyImageToBufferInfo2 stack_pCopyImageToBufferInfo[1];
1707 pCopyImageToBufferInfo = (VkCopyImageToBufferInfo2*)stack_pCopyImageToBufferInfo;
1708 reservedunmarshal_VkCopyImageToBufferInfo2(
1709 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1710 (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo), readStreamPtrPtr);
1711 if (pCopyImageToBufferInfo) {
1712 transform_tohost_VkCopyImageToBufferInfo2(
1713 globalstate, (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo));
1714 }
1715 vk->vkCmdCopyImageToBuffer2((VkCommandBuffer)dispatchHandle,
1716 pCopyImageToBufferInfo);
1717 android::base::endTrace();
1718 break;
1719 }
1720 case OP_vkCmdBlitImage2: {
1721 android::base::beginTrace("vkCmdBlitImage2 subdecode");
1722 const VkBlitImageInfo2* pBlitImageInfo;
1723 VkBlitImageInfo2 stack_pBlitImageInfo[1];
1724 pBlitImageInfo = (VkBlitImageInfo2*)stack_pBlitImageInfo;
1725 reservedunmarshal_VkBlitImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1726 (VkBlitImageInfo2*)(pBlitImageInfo),
1727 readStreamPtrPtr);
1728 if (pBlitImageInfo) {
1729 transform_tohost_VkBlitImageInfo2(globalstate,
1730 (VkBlitImageInfo2*)(pBlitImageInfo));
1731 }
1732 vk->vkCmdBlitImage2((VkCommandBuffer)dispatchHandle, pBlitImageInfo);
1733 android::base::endTrace();
1734 break;
1735 }
1736 case OP_vkCmdResolveImage2: {
1737 android::base::beginTrace("vkCmdResolveImage2 subdecode");
1738 const VkResolveImageInfo2* pResolveImageInfo;
1739 VkResolveImageInfo2 stack_pResolveImageInfo[1];
1740 pResolveImageInfo = (VkResolveImageInfo2*)stack_pResolveImageInfo;
1741 reservedunmarshal_VkResolveImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1742 (VkResolveImageInfo2*)(pResolveImageInfo),
1743 readStreamPtrPtr);
1744 if (pResolveImageInfo) {
1745 transform_tohost_VkResolveImageInfo2(globalstate,
1746 (VkResolveImageInfo2*)(pResolveImageInfo));
1747 }
1748 vk->vkCmdResolveImage2((VkCommandBuffer)dispatchHandle, pResolveImageInfo);
1749 android::base::endTrace();
1750 break;
1751 }
1752 case OP_vkCmdBeginRendering: {
1753 android::base::beginTrace("vkCmdBeginRendering subdecode");
1754 const VkRenderingInfo* pRenderingInfo;
1755 VkRenderingInfo stack_pRenderingInfo[1];
1756 pRenderingInfo = (VkRenderingInfo*)stack_pRenderingInfo;
1757 reservedunmarshal_VkRenderingInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1758 (VkRenderingInfo*)(pRenderingInfo),
1759 readStreamPtrPtr);
1760 if (pRenderingInfo) {
1761 transform_tohost_VkRenderingInfo(globalstate,
1762 (VkRenderingInfo*)(pRenderingInfo));
1763 }
1764 vk->vkCmdBeginRendering((VkCommandBuffer)dispatchHandle, pRenderingInfo);
1765 android::base::endTrace();
1766 break;
1767 }
1768 case OP_vkCmdEndRendering: {
1769 android::base::beginTrace("vkCmdEndRendering subdecode");
1770 vk->vkCmdEndRendering((VkCommandBuffer)dispatchHandle);
1771 android::base::endTrace();
1772 break;
1773 }
1774 case OP_vkCmdSetCullMode: {
1775 android::base::beginTrace("vkCmdSetCullMode subdecode");
1776 VkCullModeFlags cullMode;
1777 memcpy((VkCullModeFlags*)&cullMode, *readStreamPtrPtr, sizeof(VkCullModeFlags));
1778 *readStreamPtrPtr += sizeof(VkCullModeFlags);
1779 vk->vkCmdSetCullMode((VkCommandBuffer)dispatchHandle, cullMode);
1780 android::base::endTrace();
1781 break;
1782 }
1783 case OP_vkCmdSetFrontFace: {
1784 android::base::beginTrace("vkCmdSetFrontFace subdecode");
1785 VkFrontFace frontFace;
1786 memcpy((VkFrontFace*)&frontFace, *readStreamPtrPtr, sizeof(VkFrontFace));
1787 *readStreamPtrPtr += sizeof(VkFrontFace);
1788 vk->vkCmdSetFrontFace((VkCommandBuffer)dispatchHandle, frontFace);
1789 android::base::endTrace();
1790 break;
1791 }
1792 case OP_vkCmdSetPrimitiveTopology: {
1793 android::base::beginTrace("vkCmdSetPrimitiveTopology subdecode");
1794 VkPrimitiveTopology primitiveTopology;
1795 memcpy((VkPrimitiveTopology*)&primitiveTopology, *readStreamPtrPtr,
1796 sizeof(VkPrimitiveTopology));
1797 *readStreamPtrPtr += sizeof(VkPrimitiveTopology);
1798 vk->vkCmdSetPrimitiveTopology((VkCommandBuffer)dispatchHandle, primitiveTopology);
1799 android::base::endTrace();
1800 break;
1801 }
1802 case OP_vkCmdSetViewportWithCount: {
1803 android::base::beginTrace("vkCmdSetViewportWithCount subdecode");
1804 uint32_t viewportCount;
1805 const VkViewport* pViewports;
1806 VkViewport stack_pViewports[MAX_STACK_ITEMS];
1807 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
1808 *readStreamPtrPtr += sizeof(uint32_t);
1809 if (((viewportCount)) <= MAX_STACK_ITEMS) {
1810 pViewports = (VkViewport*)stack_pViewports;
1811 } else {
1812 readStream->alloc((void**)&pViewports,
1813 ((viewportCount)) * sizeof(const VkViewport));
1814 }
1815 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
1816 reservedunmarshal_VkViewport(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1817 (VkViewport*)(pViewports + i), readStreamPtrPtr);
1818 }
1819 if (pViewports) {
1820 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
1821 transform_tohost_VkViewport(globalstate, (VkViewport*)(pViewports + i));
1822 }
1823 }
1824 vk->vkCmdSetViewportWithCount((VkCommandBuffer)dispatchHandle, viewportCount,
1825 pViewports);
1826 android::base::endTrace();
1827 break;
1828 }
1829 case OP_vkCmdSetScissorWithCount: {
1830 android::base::beginTrace("vkCmdSetScissorWithCount subdecode");
1831 uint32_t scissorCount;
1832 const VkRect2D* pScissors;
1833 VkRect2D stack_pScissors[MAX_STACK_ITEMS];
1834 memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
1835 *readStreamPtrPtr += sizeof(uint32_t);
1836 if (((scissorCount)) <= MAX_STACK_ITEMS) {
1837 pScissors = (VkRect2D*)stack_pScissors;
1838 } else {
1839 readStream->alloc((void**)&pScissors,
1840 ((scissorCount)) * sizeof(const VkRect2D));
1841 }
1842 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
1843 reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1844 (VkRect2D*)(pScissors + i), readStreamPtrPtr);
1845 }
1846 if (pScissors) {
1847 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
1848 transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pScissors + i));
1849 }
1850 }
1851 vk->vkCmdSetScissorWithCount((VkCommandBuffer)dispatchHandle, scissorCount,
1852 pScissors);
1853 android::base::endTrace();
1854 break;
1855 }
1856 case OP_vkCmdBindVertexBuffers2: {
1857 android::base::beginTrace("vkCmdBindVertexBuffers2 subdecode");
1858 uint32_t firstBinding;
1859 uint32_t bindingCount;
1860 const VkBuffer* pBuffers;
1861 VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
1862 const VkDeviceSize* pOffsets;
1863 VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
1864 const VkDeviceSize* pSizes;
1865 VkDeviceSize stack_pSizes[MAX_STACK_ITEMS];
1866 const VkDeviceSize* pStrides;
1867 VkDeviceSize stack_pStrides[MAX_STACK_ITEMS];
1868 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
1869 *readStreamPtrPtr += sizeof(uint32_t);
1870 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
1871 *readStreamPtrPtr += sizeof(uint32_t);
1872 // WARNING PTR CHECK
1873 memcpy((VkBuffer**)&pBuffers, (*readStreamPtrPtr), 8);
1874 android::base::Stream::fromBe64((uint8_t*)&pBuffers);
1875 *readStreamPtrPtr += 8;
1876 if (pBuffers) {
1877 if (((bindingCount)) <= MAX_STACK_ITEMS) {
1878 pBuffers = (VkBuffer*)stack_pBuffers;
1879 } else {
1880 readStream->alloc((void**)&pBuffers,
1881 ((bindingCount)) * sizeof(const VkBuffer));
1882 }
1883 if (((bindingCount))) {
1884 uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*readStreamPtrPtr);
1885 *readStreamPtrPtr += 8 * ((bindingCount));
1886 for (uint32_t k = 0; k < ((bindingCount)); ++k) {
1887 uint64_t tmpval;
1888 memcpy(&tmpval, cgen_var_0_0_ptr + k * 8, sizeof(uint64_t));
1889 *(((VkBuffer*)pBuffers) + k) =
1890 (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval);
1891 }
1892 }
1893 }
1894 if (((bindingCount)) <= MAX_STACK_ITEMS) {
1895 pOffsets = (VkDeviceSize*)stack_pOffsets;
1896 } else {
1897 readStream->alloc((void**)&pOffsets,
1898 ((bindingCount)) * sizeof(const VkDeviceSize));
1899 }
1900 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
1901 ((bindingCount)) * sizeof(const VkDeviceSize));
1902 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
1903 // WARNING PTR CHECK
1904 memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
1905 android::base::Stream::fromBe64((uint8_t*)&pSizes);
1906 *readStreamPtrPtr += 8;
1907 if (pSizes) {
1908 if (((bindingCount)) <= MAX_STACK_ITEMS) {
1909 pSizes = (VkDeviceSize*)stack_pSizes;
1910 } else {
1911 readStream->alloc((void**)&pSizes,
1912 ((bindingCount)) * sizeof(const VkDeviceSize));
1913 }
1914 memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr,
1915 ((bindingCount)) * sizeof(const VkDeviceSize));
1916 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
1917 }
1918 // WARNING PTR CHECK
1919 memcpy((VkDeviceSize**)&pStrides, (*readStreamPtrPtr), 8);
1920 android::base::Stream::fromBe64((uint8_t*)&pStrides);
1921 *readStreamPtrPtr += 8;
1922 if (pStrides) {
1923 if (((bindingCount)) <= MAX_STACK_ITEMS) {
1924 pStrides = (VkDeviceSize*)stack_pStrides;
1925 } else {
1926 readStream->alloc((void**)&pStrides,
1927 ((bindingCount)) * sizeof(const VkDeviceSize));
1928 }
1929 memcpy((VkDeviceSize*)pStrides, *readStreamPtrPtr,
1930 ((bindingCount)) * sizeof(const VkDeviceSize));
1931 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
1932 }
1933 vk->vkCmdBindVertexBuffers2((VkCommandBuffer)dispatchHandle, firstBinding,
1934 bindingCount, pBuffers, pOffsets, pSizes, pStrides);
1935 android::base::endTrace();
1936 break;
1937 }
1938 case OP_vkCmdSetDepthTestEnable: {
1939 android::base::beginTrace("vkCmdSetDepthTestEnable subdecode");
1940 VkBool32 depthTestEnable;
1941 memcpy((VkBool32*)&depthTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
1942 *readStreamPtrPtr += sizeof(VkBool32);
1943 vk->vkCmdSetDepthTestEnable((VkCommandBuffer)dispatchHandle, depthTestEnable);
1944 android::base::endTrace();
1945 break;
1946 }
1947 case OP_vkCmdSetDepthWriteEnable: {
1948 android::base::beginTrace("vkCmdSetDepthWriteEnable subdecode");
1949 VkBool32 depthWriteEnable;
1950 memcpy((VkBool32*)&depthWriteEnable, *readStreamPtrPtr, sizeof(VkBool32));
1951 *readStreamPtrPtr += sizeof(VkBool32);
1952 vk->vkCmdSetDepthWriteEnable((VkCommandBuffer)dispatchHandle, depthWriteEnable);
1953 android::base::endTrace();
1954 break;
1955 }
1956 case OP_vkCmdSetDepthCompareOp: {
1957 android::base::beginTrace("vkCmdSetDepthCompareOp subdecode");
1958 VkCompareOp depthCompareOp;
1959 memcpy((VkCompareOp*)&depthCompareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
1960 *readStreamPtrPtr += sizeof(VkCompareOp);
1961 vk->vkCmdSetDepthCompareOp((VkCommandBuffer)dispatchHandle, depthCompareOp);
1962 android::base::endTrace();
1963 break;
1964 }
1965 case OP_vkCmdSetDepthBoundsTestEnable: {
1966 android::base::beginTrace("vkCmdSetDepthBoundsTestEnable subdecode");
1967 VkBool32 depthBoundsTestEnable;
1968 memcpy((VkBool32*)&depthBoundsTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
1969 *readStreamPtrPtr += sizeof(VkBool32);
1970 vk->vkCmdSetDepthBoundsTestEnable((VkCommandBuffer)dispatchHandle,
1971 depthBoundsTestEnable);
1972 android::base::endTrace();
1973 break;
1974 }
1975 case OP_vkCmdSetStencilTestEnable: {
1976 android::base::beginTrace("vkCmdSetStencilTestEnable subdecode");
1977 VkBool32 stencilTestEnable;
1978 memcpy((VkBool32*)&stencilTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
1979 *readStreamPtrPtr += sizeof(VkBool32);
1980 vk->vkCmdSetStencilTestEnable((VkCommandBuffer)dispatchHandle, stencilTestEnable);
1981 android::base::endTrace();
1982 break;
1983 }
1984 case OP_vkCmdSetStencilOp: {
1985 android::base::beginTrace("vkCmdSetStencilOp subdecode");
1986 VkStencilFaceFlags faceMask;
1987 VkStencilOp failOp;
1988 VkStencilOp passOp;
1989 VkStencilOp depthFailOp;
1990 VkCompareOp compareOp;
1991 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
1992 sizeof(VkStencilFaceFlags));
1993 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
1994 memcpy((VkStencilOp*)&failOp, *readStreamPtrPtr, sizeof(VkStencilOp));
1995 *readStreamPtrPtr += sizeof(VkStencilOp);
1996 memcpy((VkStencilOp*)&passOp, *readStreamPtrPtr, sizeof(VkStencilOp));
1997 *readStreamPtrPtr += sizeof(VkStencilOp);
1998 memcpy((VkStencilOp*)&depthFailOp, *readStreamPtrPtr, sizeof(VkStencilOp));
1999 *readStreamPtrPtr += sizeof(VkStencilOp);
2000 memcpy((VkCompareOp*)&compareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
2001 *readStreamPtrPtr += sizeof(VkCompareOp);
2002 vk->vkCmdSetStencilOp((VkCommandBuffer)dispatchHandle, faceMask, failOp, passOp,
2003 depthFailOp, compareOp);
2004 android::base::endTrace();
2005 break;
2006 }
2007 case OP_vkCmdSetRasterizerDiscardEnable: {
2008 android::base::beginTrace("vkCmdSetRasterizerDiscardEnable subdecode");
2009 VkBool32 rasterizerDiscardEnable;
2010 memcpy((VkBool32*)&rasterizerDiscardEnable, *readStreamPtrPtr, sizeof(VkBool32));
2011 *readStreamPtrPtr += sizeof(VkBool32);
2012 vk->vkCmdSetRasterizerDiscardEnable((VkCommandBuffer)dispatchHandle,
2013 rasterizerDiscardEnable);
2014 android::base::endTrace();
2015 break;
2016 }
2017 case OP_vkCmdSetDepthBiasEnable: {
2018 android::base::beginTrace("vkCmdSetDepthBiasEnable subdecode");
2019 VkBool32 depthBiasEnable;
2020 memcpy((VkBool32*)&depthBiasEnable, *readStreamPtrPtr, sizeof(VkBool32));
2021 *readStreamPtrPtr += sizeof(VkBool32);
2022 vk->vkCmdSetDepthBiasEnable((VkCommandBuffer)dispatchHandle, depthBiasEnable);
2023 android::base::endTrace();
2024 break;
2025 }
2026 case OP_vkCmdSetPrimitiveRestartEnable: {
2027 android::base::beginTrace("vkCmdSetPrimitiveRestartEnable subdecode");
2028 VkBool32 primitiveRestartEnable;
2029 memcpy((VkBool32*)&primitiveRestartEnable, *readStreamPtrPtr, sizeof(VkBool32));
2030 *readStreamPtrPtr += sizeof(VkBool32);
2031 vk->vkCmdSetPrimitiveRestartEnable((VkCommandBuffer)dispatchHandle,
2032 primitiveRestartEnable);
2033 android::base::endTrace();
2034 break;
2035 }
2036 #endif
2037 #ifdef VK_KHR_surface
2038 #endif
2039 #ifdef VK_KHR_swapchain
2040 #endif
2041 #ifdef VK_KHR_display
2042 #endif
2043 #ifdef VK_KHR_display_swapchain
2044 #endif
2045 #ifdef VK_KHR_xlib_surface
2046 #endif
2047 #ifdef VK_KHR_xcb_surface
2048 #endif
2049 #ifdef VK_KHR_wayland_surface
2050 #endif
2051 #ifdef VK_KHR_android_surface
2052 #endif
2053 #ifdef VK_KHR_win32_surface
2054 #endif
2055 #ifdef VK_KHR_sampler_mirror_clamp_to_edge
2056 #endif
2057 #ifdef VK_KHR_video_queue
2058 case OP_vkCmdBeginVideoCodingKHR: {
2059 android::base::beginTrace("vkCmdBeginVideoCodingKHR subdecode");
2060 const VkVideoBeginCodingInfoKHR* pBeginInfo;
2061 VkVideoBeginCodingInfoKHR stack_pBeginInfo[1];
2062 pBeginInfo = (VkVideoBeginCodingInfoKHR*)stack_pBeginInfo;
2063 reservedunmarshal_VkVideoBeginCodingInfoKHR(
2064 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2065 (VkVideoBeginCodingInfoKHR*)(pBeginInfo), readStreamPtrPtr);
2066 if (pBeginInfo) {
2067 transform_tohost_VkVideoBeginCodingInfoKHR(
2068 globalstate, (VkVideoBeginCodingInfoKHR*)(pBeginInfo));
2069 }
2070 vk->vkCmdBeginVideoCodingKHR((VkCommandBuffer)dispatchHandle, pBeginInfo);
2071 android::base::endTrace();
2072 break;
2073 }
2074 case OP_vkCmdEndVideoCodingKHR: {
2075 android::base::beginTrace("vkCmdEndVideoCodingKHR subdecode");
2076 const VkVideoEndCodingInfoKHR* pEndCodingInfo;
2077 VkVideoEndCodingInfoKHR stack_pEndCodingInfo[1];
2078 pEndCodingInfo = (VkVideoEndCodingInfoKHR*)stack_pEndCodingInfo;
2079 reservedunmarshal_VkVideoEndCodingInfoKHR(
2080 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2081 (VkVideoEndCodingInfoKHR*)(pEndCodingInfo), readStreamPtrPtr);
2082 if (pEndCodingInfo) {
2083 transform_tohost_VkVideoEndCodingInfoKHR(
2084 globalstate, (VkVideoEndCodingInfoKHR*)(pEndCodingInfo));
2085 }
2086 vk->vkCmdEndVideoCodingKHR((VkCommandBuffer)dispatchHandle, pEndCodingInfo);
2087 android::base::endTrace();
2088 break;
2089 }
2090 case OP_vkCmdControlVideoCodingKHR: {
2091 android::base::beginTrace("vkCmdControlVideoCodingKHR subdecode");
2092 const VkVideoCodingControlInfoKHR* pCodingControlInfo;
2093 VkVideoCodingControlInfoKHR stack_pCodingControlInfo[1];
2094 pCodingControlInfo = (VkVideoCodingControlInfoKHR*)stack_pCodingControlInfo;
2095 reservedunmarshal_VkVideoCodingControlInfoKHR(
2096 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2097 (VkVideoCodingControlInfoKHR*)(pCodingControlInfo), readStreamPtrPtr);
2098 if (pCodingControlInfo) {
2099 transform_tohost_VkVideoCodingControlInfoKHR(
2100 globalstate, (VkVideoCodingControlInfoKHR*)(pCodingControlInfo));
2101 }
2102 vk->vkCmdControlVideoCodingKHR((VkCommandBuffer)dispatchHandle, pCodingControlInfo);
2103 android::base::endTrace();
2104 break;
2105 }
2106 #endif
2107 #ifdef VK_KHR_video_decode_queue
2108 case OP_vkCmdDecodeVideoKHR: {
2109 android::base::beginTrace("vkCmdDecodeVideoKHR subdecode");
2110 const VkVideoDecodeInfoKHR* pDecodeInfo;
2111 VkVideoDecodeInfoKHR stack_pDecodeInfo[1];
2112 pDecodeInfo = (VkVideoDecodeInfoKHR*)stack_pDecodeInfo;
2113 reservedunmarshal_VkVideoDecodeInfoKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2114 (VkVideoDecodeInfoKHR*)(pDecodeInfo),
2115 readStreamPtrPtr);
2116 if (pDecodeInfo) {
2117 transform_tohost_VkVideoDecodeInfoKHR(globalstate,
2118 (VkVideoDecodeInfoKHR*)(pDecodeInfo));
2119 }
2120 vk->vkCmdDecodeVideoKHR((VkCommandBuffer)dispatchHandle, pDecodeInfo);
2121 android::base::endTrace();
2122 break;
2123 }
2124 #endif
2125 #ifdef VK_KHR_video_decode_h264
2126 #endif
2127 #ifdef VK_KHR_dynamic_rendering
2128 case OP_vkCmdBeginRenderingKHR: {
2129 android::base::beginTrace("vkCmdBeginRenderingKHR subdecode");
2130 const VkRenderingInfo* pRenderingInfo;
2131 VkRenderingInfo stack_pRenderingInfo[1];
2132 pRenderingInfo = (VkRenderingInfo*)stack_pRenderingInfo;
2133 reservedunmarshal_VkRenderingInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2134 (VkRenderingInfo*)(pRenderingInfo),
2135 readStreamPtrPtr);
2136 if (pRenderingInfo) {
2137 transform_tohost_VkRenderingInfo(globalstate,
2138 (VkRenderingInfo*)(pRenderingInfo));
2139 }
2140 vk->vkCmdBeginRenderingKHR((VkCommandBuffer)dispatchHandle, pRenderingInfo);
2141 android::base::endTrace();
2142 break;
2143 }
2144 case OP_vkCmdEndRenderingKHR: {
2145 android::base::beginTrace("vkCmdEndRenderingKHR subdecode");
2146 vk->vkCmdEndRenderingKHR((VkCommandBuffer)dispatchHandle);
2147 android::base::endTrace();
2148 break;
2149 }
2150 #endif
2151 #ifdef VK_KHR_multiview
2152 #endif
2153 #ifdef VK_KHR_get_physical_device_properties2
2154 #endif
2155 #ifdef VK_KHR_device_group
2156 case OP_vkCmdSetDeviceMaskKHR: {
2157 android::base::beginTrace("vkCmdSetDeviceMaskKHR subdecode");
2158 uint32_t deviceMask;
2159 memcpy((uint32_t*)&deviceMask, *readStreamPtrPtr, sizeof(uint32_t));
2160 *readStreamPtrPtr += sizeof(uint32_t);
2161 vk->vkCmdSetDeviceMaskKHR((VkCommandBuffer)dispatchHandle, deviceMask);
2162 android::base::endTrace();
2163 break;
2164 }
2165 case OP_vkCmdDispatchBaseKHR: {
2166 android::base::beginTrace("vkCmdDispatchBaseKHR subdecode");
2167 uint32_t baseGroupX;
2168 uint32_t baseGroupY;
2169 uint32_t baseGroupZ;
2170 uint32_t groupCountX;
2171 uint32_t groupCountY;
2172 uint32_t groupCountZ;
2173 memcpy((uint32_t*)&baseGroupX, *readStreamPtrPtr, sizeof(uint32_t));
2174 *readStreamPtrPtr += sizeof(uint32_t);
2175 memcpy((uint32_t*)&baseGroupY, *readStreamPtrPtr, sizeof(uint32_t));
2176 *readStreamPtrPtr += sizeof(uint32_t);
2177 memcpy((uint32_t*)&baseGroupZ, *readStreamPtrPtr, sizeof(uint32_t));
2178 *readStreamPtrPtr += sizeof(uint32_t);
2179 memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
2180 *readStreamPtrPtr += sizeof(uint32_t);
2181 memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
2182 *readStreamPtrPtr += sizeof(uint32_t);
2183 memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
2184 *readStreamPtrPtr += sizeof(uint32_t);
2185 vk->vkCmdDispatchBaseKHR((VkCommandBuffer)dispatchHandle, baseGroupX, baseGroupY,
2186 baseGroupZ, groupCountX, groupCountY, groupCountZ);
2187 android::base::endTrace();
2188 break;
2189 }
2190 #endif
2191 #ifdef VK_KHR_shader_draw_parameters
2192 #endif
2193 #ifdef VK_KHR_maintenance1
2194 #endif
2195 #ifdef VK_KHR_device_group_creation
2196 #endif
2197 #ifdef VK_KHR_external_memory_capabilities
2198 #endif
2199 #ifdef VK_KHR_external_memory
2200 #endif
2201 #ifdef VK_KHR_external_memory_win32
2202 #endif
2203 #ifdef VK_KHR_external_memory_fd
2204 #endif
2205 #ifdef VK_KHR_win32_keyed_mutex
2206 #endif
2207 #ifdef VK_KHR_external_semaphore_capabilities
2208 #endif
2209 #ifdef VK_KHR_external_semaphore
2210 #endif
2211 #ifdef VK_KHR_external_semaphore_win32
2212 #endif
2213 #ifdef VK_KHR_external_semaphore_fd
2214 #endif
2215 #ifdef VK_KHR_push_descriptor
2216 case OP_vkCmdPushDescriptorSetKHR: {
2217 android::base::beginTrace("vkCmdPushDescriptorSetKHR subdecode");
2218 VkPipelineBindPoint pipelineBindPoint;
2219 VkPipelineLayout layout;
2220 uint32_t set;
2221 uint32_t descriptorWriteCount;
2222 const VkWriteDescriptorSet* pDescriptorWrites;
2223 VkWriteDescriptorSet stack_pDescriptorWrites[MAX_STACK_ITEMS];
2224 memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
2225 sizeof(VkPipelineBindPoint));
2226 *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
2227 uint64_t cgen_var_0;
2228 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2229 *readStreamPtrPtr += 1 * 8;
2230 *(VkPipelineLayout*)&layout =
2231 (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
2232 memcpy((uint32_t*)&set, *readStreamPtrPtr, sizeof(uint32_t));
2233 *readStreamPtrPtr += sizeof(uint32_t);
2234 memcpy((uint32_t*)&descriptorWriteCount, *readStreamPtrPtr, sizeof(uint32_t));
2235 *readStreamPtrPtr += sizeof(uint32_t);
2236 if (((descriptorWriteCount)) <= MAX_STACK_ITEMS) {
2237 pDescriptorWrites = (VkWriteDescriptorSet*)stack_pDescriptorWrites;
2238 } else {
2239 readStream->alloc(
2240 (void**)&pDescriptorWrites,
2241 ((descriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
2242 }
2243 for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
2244 reservedunmarshal_VkWriteDescriptorSet(
2245 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2246 (VkWriteDescriptorSet*)(pDescriptorWrites + i), readStreamPtrPtr);
2247 }
2248 if (pDescriptorWrites) {
2249 for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
2250 transform_tohost_VkWriteDescriptorSet(
2251 globalstate, (VkWriteDescriptorSet*)(pDescriptorWrites + i));
2252 }
2253 }
2254 vk->vkCmdPushDescriptorSetKHR((VkCommandBuffer)dispatchHandle, pipelineBindPoint,
2255 layout, set, descriptorWriteCount, pDescriptorWrites);
2256 android::base::endTrace();
2257 break;
2258 }
2259 case OP_vkCmdPushDescriptorSetWithTemplateKHR: {
2260 android::base::beginTrace("vkCmdPushDescriptorSetWithTemplateKHR subdecode");
2261 VkDescriptorUpdateTemplate descriptorUpdateTemplate;
2262 VkPipelineLayout layout;
2263 uint32_t set;
2264 const void* pData;
2265 uint8_t* stack_pData[1];
2266 uint64_t cgen_var_0;
2267 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2268 *readStreamPtrPtr += 1 * 8;
2269 *(VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate =
2270 (VkDescriptorUpdateTemplate)unbox_VkDescriptorUpdateTemplate(
2271 (VkDescriptorUpdateTemplate)(*&cgen_var_0));
2272 uint64_t cgen_var_1;
2273 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2274 *readStreamPtrPtr += 1 * 8;
2275 *(VkPipelineLayout*)&layout =
2276 (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_1));
2277 memcpy((uint32_t*)&set, *readStreamPtrPtr, sizeof(uint32_t));
2278 *readStreamPtrPtr += sizeof(uint32_t);
2279 // WARNING PTR CHECK
2280 memcpy((void**)&pData, (*readStreamPtrPtr), 8);
2281 android::base::Stream::fromBe64((uint8_t*)&pData);
2282 *readStreamPtrPtr += 8;
2283 if (pData) {
2284 pData = (void*)stack_pData;
2285 memcpy((void*)pData, *readStreamPtrPtr, sizeof(const uint8_t));
2286 *readStreamPtrPtr += sizeof(const uint8_t);
2287 }
2288 vk->vkCmdPushDescriptorSetWithTemplateKHR(
2289 (VkCommandBuffer)dispatchHandle, descriptorUpdateTemplate, layout, set, pData);
2290 android::base::endTrace();
2291 break;
2292 }
2293 #endif
2294 #ifdef VK_KHR_shader_float16_int8
2295 #endif
2296 #ifdef VK_KHR_16bit_storage
2297 #endif
2298 #ifdef VK_KHR_incremental_present
2299 #endif
2300 #ifdef VK_KHR_descriptor_update_template
2301 #endif
2302 #ifdef VK_KHR_imageless_framebuffer
2303 #endif
2304 #ifdef VK_KHR_create_renderpass2
2305 case OP_vkCmdBeginRenderPass2KHR: {
2306 android::base::beginTrace("vkCmdBeginRenderPass2KHR subdecode");
2307 const VkRenderPassBeginInfo* pRenderPassBegin;
2308 VkRenderPassBeginInfo stack_pRenderPassBegin[1];
2309 const VkSubpassBeginInfo* pSubpassBeginInfo;
2310 VkSubpassBeginInfo stack_pSubpassBeginInfo[1];
2311 pRenderPassBegin = (VkRenderPassBeginInfo*)stack_pRenderPassBegin;
2312 reservedunmarshal_VkRenderPassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2313 (VkRenderPassBeginInfo*)(pRenderPassBegin),
2314 readStreamPtrPtr);
2315 pSubpassBeginInfo = (VkSubpassBeginInfo*)stack_pSubpassBeginInfo;
2316 reservedunmarshal_VkSubpassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2317 (VkSubpassBeginInfo*)(pSubpassBeginInfo),
2318 readStreamPtrPtr);
2319 if (pRenderPassBegin) {
2320 transform_tohost_VkRenderPassBeginInfo(
2321 globalstate, (VkRenderPassBeginInfo*)(pRenderPassBegin));
2322 }
2323 if (pSubpassBeginInfo) {
2324 transform_tohost_VkSubpassBeginInfo(globalstate,
2325 (VkSubpassBeginInfo*)(pSubpassBeginInfo));
2326 }
2327 vk->vkCmdBeginRenderPass2KHR((VkCommandBuffer)dispatchHandle, pRenderPassBegin,
2328 pSubpassBeginInfo);
2329 android::base::endTrace();
2330 break;
2331 }
2332 case OP_vkCmdNextSubpass2KHR: {
2333 android::base::beginTrace("vkCmdNextSubpass2KHR subdecode");
2334 const VkSubpassBeginInfo* pSubpassBeginInfo;
2335 VkSubpassBeginInfo stack_pSubpassBeginInfo[1];
2336 const VkSubpassEndInfo* pSubpassEndInfo;
2337 VkSubpassEndInfo stack_pSubpassEndInfo[1];
2338 pSubpassBeginInfo = (VkSubpassBeginInfo*)stack_pSubpassBeginInfo;
2339 reservedunmarshal_VkSubpassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2340 (VkSubpassBeginInfo*)(pSubpassBeginInfo),
2341 readStreamPtrPtr);
2342 pSubpassEndInfo = (VkSubpassEndInfo*)stack_pSubpassEndInfo;
2343 reservedunmarshal_VkSubpassEndInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2344 (VkSubpassEndInfo*)(pSubpassEndInfo),
2345 readStreamPtrPtr);
2346 if (pSubpassBeginInfo) {
2347 transform_tohost_VkSubpassBeginInfo(globalstate,
2348 (VkSubpassBeginInfo*)(pSubpassBeginInfo));
2349 }
2350 if (pSubpassEndInfo) {
2351 transform_tohost_VkSubpassEndInfo(globalstate,
2352 (VkSubpassEndInfo*)(pSubpassEndInfo));
2353 }
2354 vk->vkCmdNextSubpass2KHR((VkCommandBuffer)dispatchHandle, pSubpassBeginInfo,
2355 pSubpassEndInfo);
2356 android::base::endTrace();
2357 break;
2358 }
2359 case OP_vkCmdEndRenderPass2KHR: {
2360 android::base::beginTrace("vkCmdEndRenderPass2KHR subdecode");
2361 const VkSubpassEndInfo* pSubpassEndInfo;
2362 VkSubpassEndInfo stack_pSubpassEndInfo[1];
2363 pSubpassEndInfo = (VkSubpassEndInfo*)stack_pSubpassEndInfo;
2364 reservedunmarshal_VkSubpassEndInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2365 (VkSubpassEndInfo*)(pSubpassEndInfo),
2366 readStreamPtrPtr);
2367 if (pSubpassEndInfo) {
2368 transform_tohost_VkSubpassEndInfo(globalstate,
2369 (VkSubpassEndInfo*)(pSubpassEndInfo));
2370 }
2371 vk->vkCmdEndRenderPass2KHR((VkCommandBuffer)dispatchHandle, pSubpassEndInfo);
2372 android::base::endTrace();
2373 break;
2374 }
2375 #endif
2376 #ifdef VK_KHR_shared_presentable_image
2377 #endif
2378 #ifdef VK_KHR_external_fence_capabilities
2379 #endif
2380 #ifdef VK_KHR_external_fence
2381 #endif
2382 #ifdef VK_KHR_external_fence_win32
2383 #endif
2384 #ifdef VK_KHR_external_fence_fd
2385 #endif
2386 #ifdef VK_KHR_performance_query
2387 #endif
2388 #ifdef VK_KHR_maintenance2
2389 #endif
2390 #ifdef VK_KHR_get_surface_capabilities2
2391 #endif
2392 #ifdef VK_KHR_variable_pointers
2393 #endif
2394 #ifdef VK_KHR_get_display_properties2
2395 #endif
2396 #ifdef VK_KHR_dedicated_allocation
2397 #endif
2398 #ifdef VK_KHR_storage_buffer_storage_class
2399 #endif
2400 #ifdef VK_KHR_relaxed_block_layout
2401 #endif
2402 #ifdef VK_KHR_get_memory_requirements2
2403 #endif
2404 #ifdef VK_KHR_image_format_list
2405 #endif
2406 #ifdef VK_KHR_sampler_ycbcr_conversion
2407 #endif
2408 #ifdef VK_KHR_bind_memory2
2409 #endif
2410 #ifdef VK_KHR_portability_subset
2411 #endif
2412 #ifdef VK_KHR_maintenance3
2413 #endif
2414 #ifdef VK_KHR_draw_indirect_count
2415 case OP_vkCmdDrawIndirectCountKHR: {
2416 android::base::beginTrace("vkCmdDrawIndirectCountKHR subdecode");
2417 VkBuffer buffer;
2418 VkDeviceSize offset;
2419 VkBuffer countBuffer;
2420 VkDeviceSize countBufferOffset;
2421 uint32_t maxDrawCount;
2422 uint32_t stride;
2423 uint64_t cgen_var_0;
2424 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2425 *readStreamPtrPtr += 1 * 8;
2426 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
2427 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2428 *readStreamPtrPtr += sizeof(VkDeviceSize);
2429 uint64_t cgen_var_1;
2430 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2431 *readStreamPtrPtr += 1 * 8;
2432 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
2433 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2434 *readStreamPtrPtr += sizeof(VkDeviceSize);
2435 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
2436 *readStreamPtrPtr += sizeof(uint32_t);
2437 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
2438 *readStreamPtrPtr += sizeof(uint32_t);
2439 vk->vkCmdDrawIndirectCountKHR((VkCommandBuffer)dispatchHandle, buffer, offset,
2440 countBuffer, countBufferOffset, maxDrawCount, stride);
2441 android::base::endTrace();
2442 break;
2443 }
2444 case OP_vkCmdDrawIndexedIndirectCountKHR: {
2445 android::base::beginTrace("vkCmdDrawIndexedIndirectCountKHR subdecode");
2446 VkBuffer buffer;
2447 VkDeviceSize offset;
2448 VkBuffer countBuffer;
2449 VkDeviceSize countBufferOffset;
2450 uint32_t maxDrawCount;
2451 uint32_t stride;
2452 uint64_t cgen_var_0;
2453 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2454 *readStreamPtrPtr += 1 * 8;
2455 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
2456 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2457 *readStreamPtrPtr += sizeof(VkDeviceSize);
2458 uint64_t cgen_var_1;
2459 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2460 *readStreamPtrPtr += 1 * 8;
2461 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
2462 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2463 *readStreamPtrPtr += sizeof(VkDeviceSize);
2464 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
2465 *readStreamPtrPtr += sizeof(uint32_t);
2466 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
2467 *readStreamPtrPtr += sizeof(uint32_t);
2468 vk->vkCmdDrawIndexedIndirectCountKHR((VkCommandBuffer)dispatchHandle, buffer,
2469 offset, countBuffer, countBufferOffset,
2470 maxDrawCount, stride);
2471 android::base::endTrace();
2472 break;
2473 }
2474 #endif
2475 #ifdef VK_KHR_shader_subgroup_extended_types
2476 #endif
2477 #ifdef VK_KHR_8bit_storage
2478 #endif
2479 #ifdef VK_KHR_shader_atomic_int64
2480 #endif
2481 #ifdef VK_KHR_shader_clock
2482 #endif
2483 #ifdef VK_KHR_video_decode_h265
2484 #endif
2485 #ifdef VK_KHR_global_priority
2486 #endif
2487 #ifdef VK_KHR_driver_properties
2488 #endif
2489 #ifdef VK_KHR_shader_float_controls
2490 #endif
2491 #ifdef VK_KHR_depth_stencil_resolve
2492 #endif
2493 #ifdef VK_KHR_swapchain_mutable_format
2494 #endif
2495 #ifdef VK_KHR_timeline_semaphore
2496 #endif
2497 #ifdef VK_KHR_vulkan_memory_model
2498 #endif
2499 #ifdef VK_KHR_shader_terminate_invocation
2500 #endif
2501 #ifdef VK_KHR_fragment_shading_rate
2502 case OP_vkCmdSetFragmentShadingRateKHR: {
2503 android::base::beginTrace("vkCmdSetFragmentShadingRateKHR subdecode");
2504 const VkExtent2D* pFragmentSize;
2505 VkExtent2D stack_pFragmentSize[1];
2506 VkFragmentShadingRateCombinerOpKHR combinerOps[2];
2507 pFragmentSize = (VkExtent2D*)stack_pFragmentSize;
2508 reservedunmarshal_VkExtent2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2509 (VkExtent2D*)(pFragmentSize), readStreamPtrPtr);
2510 memcpy((VkFragmentShadingRateCombinerOpKHR*)combinerOps, *readStreamPtrPtr,
2511 2 * sizeof(const VkFragmentShadingRateCombinerOpKHR));
2512 *readStreamPtrPtr += 2 * sizeof(const VkFragmentShadingRateCombinerOpKHR);
2513 if (pFragmentSize) {
2514 transform_tohost_VkExtent2D(globalstate, (VkExtent2D*)(pFragmentSize));
2515 }
2516 vk->vkCmdSetFragmentShadingRateKHR((VkCommandBuffer)dispatchHandle, pFragmentSize,
2517 combinerOps);
2518 android::base::endTrace();
2519 break;
2520 }
2521 #endif
2522 #ifdef VK_KHR_spirv_1_4
2523 #endif
2524 #ifdef VK_KHR_surface_protected_capabilities
2525 #endif
2526 #ifdef VK_KHR_separate_depth_stencil_layouts
2527 #endif
2528 #ifdef VK_KHR_present_wait
2529 #endif
2530 #ifdef VK_KHR_uniform_buffer_standard_layout
2531 #endif
2532 #ifdef VK_KHR_buffer_device_address
2533 #endif
2534 #ifdef VK_KHR_deferred_host_operations
2535 #endif
2536 #ifdef VK_KHR_pipeline_executable_properties
2537 #endif
2538 #ifdef VK_KHR_map_memory2
2539 #endif
2540 #ifdef VK_KHR_shader_integer_dot_product
2541 #endif
2542 #ifdef VK_KHR_pipeline_library
2543 #endif
2544 #ifdef VK_KHR_shader_non_semantic_info
2545 #endif
2546 #ifdef VK_KHR_present_id
2547 #endif
2548 #ifdef VK_KHR_video_encode_queue
2549 case OP_vkCmdEncodeVideoKHR: {
2550 android::base::beginTrace("vkCmdEncodeVideoKHR subdecode");
2551 const VkVideoEncodeInfoKHR* pEncodeInfo;
2552 VkVideoEncodeInfoKHR stack_pEncodeInfo[1];
2553 pEncodeInfo = (VkVideoEncodeInfoKHR*)stack_pEncodeInfo;
2554 reservedunmarshal_VkVideoEncodeInfoKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2555 (VkVideoEncodeInfoKHR*)(pEncodeInfo),
2556 readStreamPtrPtr);
2557 if (pEncodeInfo) {
2558 transform_tohost_VkVideoEncodeInfoKHR(globalstate,
2559 (VkVideoEncodeInfoKHR*)(pEncodeInfo));
2560 }
2561 vk->vkCmdEncodeVideoKHR((VkCommandBuffer)dispatchHandle, pEncodeInfo);
2562 android::base::endTrace();
2563 break;
2564 }
2565 #endif
2566 #ifdef VK_KHR_synchronization2
2567 case OP_vkCmdSetEvent2KHR: {
2568 android::base::beginTrace("vkCmdSetEvent2KHR subdecode");
2569 VkEvent event;
2570 const VkDependencyInfo* pDependencyInfo;
2571 VkDependencyInfo stack_pDependencyInfo[1];
2572 uint64_t cgen_var_0;
2573 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2574 *readStreamPtrPtr += 1 * 8;
2575 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
2576 pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
2577 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2578 (VkDependencyInfo*)(pDependencyInfo),
2579 readStreamPtrPtr);
2580 if (pDependencyInfo) {
2581 transform_tohost_VkDependencyInfo(globalstate,
2582 (VkDependencyInfo*)(pDependencyInfo));
2583 }
2584 vk->vkCmdSetEvent2KHR((VkCommandBuffer)dispatchHandle, event, pDependencyInfo);
2585 android::base::endTrace();
2586 break;
2587 }
2588 case OP_vkCmdResetEvent2KHR: {
2589 android::base::beginTrace("vkCmdResetEvent2KHR subdecode");
2590 VkEvent event;
2591 VkPipelineStageFlags2 stageMask;
2592 uint64_t cgen_var_0;
2593 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2594 *readStreamPtrPtr += 1 * 8;
2595 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
2596 memcpy((VkPipelineStageFlags2*)&stageMask, *readStreamPtrPtr,
2597 sizeof(VkPipelineStageFlags2));
2598 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
2599 vk->vkCmdResetEvent2KHR((VkCommandBuffer)dispatchHandle, event, stageMask);
2600 android::base::endTrace();
2601 break;
2602 }
2603 case OP_vkCmdWaitEvents2KHR: {
2604 android::base::beginTrace("vkCmdWaitEvents2KHR subdecode");
2605 uint32_t eventCount;
2606 const VkEvent* pEvents;
2607 VkEvent stack_pEvents[MAX_STACK_ITEMS];
2608 const VkDependencyInfo* pDependencyInfos;
2609 VkDependencyInfo stack_pDependencyInfos[MAX_STACK_ITEMS];
2610 memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
2611 *readStreamPtrPtr += sizeof(uint32_t);
2612 if (((eventCount)) <= MAX_STACK_ITEMS) {
2613 pEvents = (VkEvent*)stack_pEvents;
2614 } else {
2615 readStream->alloc((void**)&pEvents, ((eventCount)) * sizeof(const VkEvent));
2616 }
2617 if (((eventCount))) {
2618 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
2619 *readStreamPtrPtr += 8 * ((eventCount));
2620 for (uint32_t k = 0; k < ((eventCount)); ++k) {
2621 uint64_t tmpval;
2622 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
2623 *(((VkEvent*)pEvents) + k) = (VkEvent)unbox_VkEvent((VkEvent)tmpval);
2624 }
2625 }
2626 if (((eventCount)) <= MAX_STACK_ITEMS) {
2627 pDependencyInfos = (VkDependencyInfo*)stack_pDependencyInfos;
2628 } else {
2629 readStream->alloc((void**)&pDependencyInfos,
2630 ((eventCount)) * sizeof(const VkDependencyInfo));
2631 }
2632 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
2633 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2634 (VkDependencyInfo*)(pDependencyInfos + i),
2635 readStreamPtrPtr);
2636 }
2637 if (pDependencyInfos) {
2638 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
2639 transform_tohost_VkDependencyInfo(
2640 globalstate, (VkDependencyInfo*)(pDependencyInfos + i));
2641 }
2642 }
2643 vk->vkCmdWaitEvents2KHR((VkCommandBuffer)dispatchHandle, eventCount, pEvents,
2644 pDependencyInfos);
2645 android::base::endTrace();
2646 break;
2647 }
2648 case OP_vkCmdPipelineBarrier2KHR: {
2649 android::base::beginTrace("vkCmdPipelineBarrier2KHR subdecode");
2650 const VkDependencyInfo* pDependencyInfo;
2651 VkDependencyInfo stack_pDependencyInfo[1];
2652 pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
2653 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2654 (VkDependencyInfo*)(pDependencyInfo),
2655 readStreamPtrPtr);
2656 if (pDependencyInfo) {
2657 transform_tohost_VkDependencyInfo(globalstate,
2658 (VkDependencyInfo*)(pDependencyInfo));
2659 }
2660 vk->vkCmdPipelineBarrier2KHR((VkCommandBuffer)dispatchHandle, pDependencyInfo);
2661 android::base::endTrace();
2662 break;
2663 }
2664 case OP_vkCmdWriteTimestamp2KHR: {
2665 android::base::beginTrace("vkCmdWriteTimestamp2KHR subdecode");
2666 VkPipelineStageFlags2 stage;
2667 VkQueryPool queryPool;
2668 uint32_t query;
2669 memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
2670 sizeof(VkPipelineStageFlags2));
2671 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
2672 uint64_t cgen_var_0;
2673 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2674 *readStreamPtrPtr += 1 * 8;
2675 *(VkQueryPool*)&queryPool =
2676 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
2677 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
2678 *readStreamPtrPtr += sizeof(uint32_t);
2679 vk->vkCmdWriteTimestamp2KHR((VkCommandBuffer)dispatchHandle, stage, queryPool,
2680 query);
2681 android::base::endTrace();
2682 break;
2683 }
2684 case OP_vkCmdWriteBufferMarker2AMD: {
2685 android::base::beginTrace("vkCmdWriteBufferMarker2AMD subdecode");
2686 VkPipelineStageFlags2 stage;
2687 VkBuffer dstBuffer;
2688 VkDeviceSize dstOffset;
2689 uint32_t marker;
2690 memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
2691 sizeof(VkPipelineStageFlags2));
2692 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
2693 uint64_t cgen_var_0;
2694 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2695 *readStreamPtrPtr += 1 * 8;
2696 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
2697 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2698 *readStreamPtrPtr += sizeof(VkDeviceSize);
2699 memcpy((uint32_t*)&marker, *readStreamPtrPtr, sizeof(uint32_t));
2700 *readStreamPtrPtr += sizeof(uint32_t);
2701 vk->vkCmdWriteBufferMarker2AMD((VkCommandBuffer)dispatchHandle, stage, dstBuffer,
2702 dstOffset, marker);
2703 android::base::endTrace();
2704 break;
2705 }
2706 #endif
2707 #ifdef VK_KHR_fragment_shader_barycentric
2708 #endif
2709 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
2710 #endif
2711 #ifdef VK_KHR_zero_initialize_workgroup_memory
2712 #endif
2713 #ifdef VK_KHR_workgroup_memory_explicit_layout
2714 #endif
2715 #ifdef VK_KHR_copy_commands2
2716 case OP_vkCmdCopyBuffer2KHR: {
2717 android::base::beginTrace("vkCmdCopyBuffer2KHR subdecode");
2718 const VkCopyBufferInfo2* pCopyBufferInfo;
2719 VkCopyBufferInfo2 stack_pCopyBufferInfo[1];
2720 pCopyBufferInfo = (VkCopyBufferInfo2*)stack_pCopyBufferInfo;
2721 reservedunmarshal_VkCopyBufferInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2722 (VkCopyBufferInfo2*)(pCopyBufferInfo),
2723 readStreamPtrPtr);
2724 if (pCopyBufferInfo) {
2725 transform_tohost_VkCopyBufferInfo2(globalstate,
2726 (VkCopyBufferInfo2*)(pCopyBufferInfo));
2727 }
2728 vk->vkCmdCopyBuffer2KHR((VkCommandBuffer)dispatchHandle, pCopyBufferInfo);
2729 android::base::endTrace();
2730 break;
2731 }
2732 case OP_vkCmdCopyImage2KHR: {
2733 android::base::beginTrace("vkCmdCopyImage2KHR subdecode");
2734 const VkCopyImageInfo2* pCopyImageInfo;
2735 VkCopyImageInfo2 stack_pCopyImageInfo[1];
2736 pCopyImageInfo = (VkCopyImageInfo2*)stack_pCopyImageInfo;
2737 reservedunmarshal_VkCopyImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2738 (VkCopyImageInfo2*)(pCopyImageInfo),
2739 readStreamPtrPtr);
2740 if (pCopyImageInfo) {
2741 transform_tohost_VkCopyImageInfo2(globalstate,
2742 (VkCopyImageInfo2*)(pCopyImageInfo));
2743 }
2744 vk->vkCmdCopyImage2KHR((VkCommandBuffer)dispatchHandle, pCopyImageInfo);
2745 android::base::endTrace();
2746 break;
2747 }
2748 case OP_vkCmdCopyBufferToImage2KHR: {
2749 android::base::beginTrace("vkCmdCopyBufferToImage2KHR subdecode");
2750 const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo;
2751 VkCopyBufferToImageInfo2 stack_pCopyBufferToImageInfo[1];
2752 pCopyBufferToImageInfo = (VkCopyBufferToImageInfo2*)stack_pCopyBufferToImageInfo;
2753 reservedunmarshal_VkCopyBufferToImageInfo2(
2754 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2755 (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo), readStreamPtrPtr);
2756 if (pCopyBufferToImageInfo) {
2757 transform_tohost_VkCopyBufferToImageInfo2(
2758 globalstate, (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo));
2759 }
2760 vk->vkCmdCopyBufferToImage2KHR((VkCommandBuffer)dispatchHandle,
2761 pCopyBufferToImageInfo);
2762 android::base::endTrace();
2763 break;
2764 }
2765 case OP_vkCmdCopyImageToBuffer2KHR: {
2766 android::base::beginTrace("vkCmdCopyImageToBuffer2KHR subdecode");
2767 const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo;
2768 VkCopyImageToBufferInfo2 stack_pCopyImageToBufferInfo[1];
2769 pCopyImageToBufferInfo = (VkCopyImageToBufferInfo2*)stack_pCopyImageToBufferInfo;
2770 reservedunmarshal_VkCopyImageToBufferInfo2(
2771 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2772 (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo), readStreamPtrPtr);
2773 if (pCopyImageToBufferInfo) {
2774 transform_tohost_VkCopyImageToBufferInfo2(
2775 globalstate, (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo));
2776 }
2777 vk->vkCmdCopyImageToBuffer2KHR((VkCommandBuffer)dispatchHandle,
2778 pCopyImageToBufferInfo);
2779 android::base::endTrace();
2780 break;
2781 }
2782 case OP_vkCmdBlitImage2KHR: {
2783 android::base::beginTrace("vkCmdBlitImage2KHR subdecode");
2784 const VkBlitImageInfo2* pBlitImageInfo;
2785 VkBlitImageInfo2 stack_pBlitImageInfo[1];
2786 pBlitImageInfo = (VkBlitImageInfo2*)stack_pBlitImageInfo;
2787 reservedunmarshal_VkBlitImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2788 (VkBlitImageInfo2*)(pBlitImageInfo),
2789 readStreamPtrPtr);
2790 if (pBlitImageInfo) {
2791 transform_tohost_VkBlitImageInfo2(globalstate,
2792 (VkBlitImageInfo2*)(pBlitImageInfo));
2793 }
2794 vk->vkCmdBlitImage2KHR((VkCommandBuffer)dispatchHandle, pBlitImageInfo);
2795 android::base::endTrace();
2796 break;
2797 }
2798 case OP_vkCmdResolveImage2KHR: {
2799 android::base::beginTrace("vkCmdResolveImage2KHR subdecode");
2800 const VkResolveImageInfo2* pResolveImageInfo;
2801 VkResolveImageInfo2 stack_pResolveImageInfo[1];
2802 pResolveImageInfo = (VkResolveImageInfo2*)stack_pResolveImageInfo;
2803 reservedunmarshal_VkResolveImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2804 (VkResolveImageInfo2*)(pResolveImageInfo),
2805 readStreamPtrPtr);
2806 if (pResolveImageInfo) {
2807 transform_tohost_VkResolveImageInfo2(globalstate,
2808 (VkResolveImageInfo2*)(pResolveImageInfo));
2809 }
2810 vk->vkCmdResolveImage2KHR((VkCommandBuffer)dispatchHandle, pResolveImageInfo);
2811 android::base::endTrace();
2812 break;
2813 }
2814 #endif
2815 #ifdef VK_KHR_format_feature_flags2
2816 #endif
2817 #ifdef VK_KHR_ray_tracing_maintenance1
2818 case OP_vkCmdTraceRaysIndirect2KHR: {
2819 android::base::beginTrace("vkCmdTraceRaysIndirect2KHR subdecode");
2820 VkDeviceAddress indirectDeviceAddress;
2821 memcpy((VkDeviceAddress*)&indirectDeviceAddress, *readStreamPtrPtr,
2822 sizeof(VkDeviceAddress));
2823 *readStreamPtrPtr += sizeof(VkDeviceAddress);
2824 vk->vkCmdTraceRaysIndirect2KHR((VkCommandBuffer)dispatchHandle,
2825 indirectDeviceAddress);
2826 android::base::endTrace();
2827 break;
2828 }
2829 #endif
2830 #ifdef VK_KHR_portability_enumeration
2831 #endif
2832 #ifdef VK_KHR_maintenance4
2833 #endif
2834 #ifdef VK_KHR_ray_tracing_position_fetch
2835 #endif
2836 #ifdef VK_ANDROID_native_buffer
2837 #endif
2838 #ifdef VK_EXT_debug_report
2839 #endif
2840 #ifdef VK_NV_glsl_shader
2841 #endif
2842 #ifdef VK_EXT_depth_range_unrestricted
2843 #endif
2844 #ifdef VK_IMG_filter_cubic
2845 #endif
2846 #ifdef VK_AMD_rasterization_order
2847 #endif
2848 #ifdef VK_AMD_shader_trinary_minmax
2849 #endif
2850 #ifdef VK_AMD_shader_explicit_vertex_parameter
2851 #endif
2852 #ifdef VK_EXT_debug_marker
2853 case OP_vkCmdDebugMarkerBeginEXT: {
2854 android::base::beginTrace("vkCmdDebugMarkerBeginEXT subdecode");
2855 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo;
2856 VkDebugMarkerMarkerInfoEXT stack_pMarkerInfo[1];
2857 pMarkerInfo = (VkDebugMarkerMarkerInfoEXT*)stack_pMarkerInfo;
2858 reservedunmarshal_VkDebugMarkerMarkerInfoEXT(
2859 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2860 (VkDebugMarkerMarkerInfoEXT*)(pMarkerInfo), readStreamPtrPtr);
2861 if (pMarkerInfo) {
2862 transform_tohost_VkDebugMarkerMarkerInfoEXT(
2863 globalstate, (VkDebugMarkerMarkerInfoEXT*)(pMarkerInfo));
2864 }
2865 vk->vkCmdDebugMarkerBeginEXT((VkCommandBuffer)dispatchHandle, pMarkerInfo);
2866 android::base::endTrace();
2867 break;
2868 }
2869 case OP_vkCmdDebugMarkerEndEXT: {
2870 android::base::beginTrace("vkCmdDebugMarkerEndEXT subdecode");
2871 vk->vkCmdDebugMarkerEndEXT((VkCommandBuffer)dispatchHandle);
2872 android::base::endTrace();
2873 break;
2874 }
2875 case OP_vkCmdDebugMarkerInsertEXT: {
2876 android::base::beginTrace("vkCmdDebugMarkerInsertEXT subdecode");
2877 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo;
2878 VkDebugMarkerMarkerInfoEXT stack_pMarkerInfo[1];
2879 pMarkerInfo = (VkDebugMarkerMarkerInfoEXT*)stack_pMarkerInfo;
2880 reservedunmarshal_VkDebugMarkerMarkerInfoEXT(
2881 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2882 (VkDebugMarkerMarkerInfoEXT*)(pMarkerInfo), readStreamPtrPtr);
2883 if (pMarkerInfo) {
2884 transform_tohost_VkDebugMarkerMarkerInfoEXT(
2885 globalstate, (VkDebugMarkerMarkerInfoEXT*)(pMarkerInfo));
2886 }
2887 vk->vkCmdDebugMarkerInsertEXT((VkCommandBuffer)dispatchHandle, pMarkerInfo);
2888 android::base::endTrace();
2889 break;
2890 }
2891 #endif
2892 #ifdef VK_AMD_gcn_shader
2893 #endif
2894 #ifdef VK_NV_dedicated_allocation
2895 #endif
2896 #ifdef VK_EXT_transform_feedback
2897 case OP_vkCmdBindTransformFeedbackBuffersEXT: {
2898 android::base::beginTrace("vkCmdBindTransformFeedbackBuffersEXT subdecode");
2899 uint32_t firstBinding;
2900 uint32_t bindingCount;
2901 const VkBuffer* pBuffers;
2902 VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
2903 const VkDeviceSize* pOffsets;
2904 VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
2905 const VkDeviceSize* pSizes;
2906 VkDeviceSize stack_pSizes[MAX_STACK_ITEMS];
2907 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
2908 *readStreamPtrPtr += sizeof(uint32_t);
2909 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
2910 *readStreamPtrPtr += sizeof(uint32_t);
2911 if (((bindingCount)) <= MAX_STACK_ITEMS) {
2912 pBuffers = (VkBuffer*)stack_pBuffers;
2913 } else {
2914 readStream->alloc((void**)&pBuffers, ((bindingCount)) * sizeof(const VkBuffer));
2915 }
2916 if (((bindingCount))) {
2917 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
2918 *readStreamPtrPtr += 8 * ((bindingCount));
2919 for (uint32_t k = 0; k < ((bindingCount)); ++k) {
2920 uint64_t tmpval;
2921 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
2922 *(((VkBuffer*)pBuffers) + k) = (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval);
2923 }
2924 }
2925 if (((bindingCount)) <= MAX_STACK_ITEMS) {
2926 pOffsets = (VkDeviceSize*)stack_pOffsets;
2927 } else {
2928 readStream->alloc((void**)&pOffsets,
2929 ((bindingCount)) * sizeof(const VkDeviceSize));
2930 }
2931 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
2932 ((bindingCount)) * sizeof(const VkDeviceSize));
2933 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
2934 // WARNING PTR CHECK
2935 memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
2936 android::base::Stream::fromBe64((uint8_t*)&pSizes);
2937 *readStreamPtrPtr += 8;
2938 if (pSizes) {
2939 if (((bindingCount)) <= MAX_STACK_ITEMS) {
2940 pSizes = (VkDeviceSize*)stack_pSizes;
2941 } else {
2942 readStream->alloc((void**)&pSizes,
2943 ((bindingCount)) * sizeof(const VkDeviceSize));
2944 }
2945 memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr,
2946 ((bindingCount)) * sizeof(const VkDeviceSize));
2947 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
2948 }
2949 vk->vkCmdBindTransformFeedbackBuffersEXT((VkCommandBuffer)dispatchHandle,
2950 firstBinding, bindingCount, pBuffers,
2951 pOffsets, pSizes);
2952 android::base::endTrace();
2953 break;
2954 }
2955 case OP_vkCmdBeginTransformFeedbackEXT: {
2956 android::base::beginTrace("vkCmdBeginTransformFeedbackEXT subdecode");
2957 uint32_t firstCounterBuffer;
2958 uint32_t counterBufferCount;
2959 const VkBuffer* pCounterBuffers;
2960 VkBuffer stack_pCounterBuffers[MAX_STACK_ITEMS];
2961 const VkDeviceSize* pCounterBufferOffsets;
2962 VkDeviceSize stack_pCounterBufferOffsets[MAX_STACK_ITEMS];
2963 memcpy((uint32_t*)&firstCounterBuffer, *readStreamPtrPtr, sizeof(uint32_t));
2964 *readStreamPtrPtr += sizeof(uint32_t);
2965 memcpy((uint32_t*)&counterBufferCount, *readStreamPtrPtr, sizeof(uint32_t));
2966 *readStreamPtrPtr += sizeof(uint32_t);
2967 // WARNING PTR CHECK
2968 memcpy((VkBuffer**)&pCounterBuffers, (*readStreamPtrPtr), 8);
2969 android::base::Stream::fromBe64((uint8_t*)&pCounterBuffers);
2970 *readStreamPtrPtr += 8;
2971 if (pCounterBuffers) {
2972 if (((counterBufferCount)) <= MAX_STACK_ITEMS) {
2973 pCounterBuffers = (VkBuffer*)stack_pCounterBuffers;
2974 } else {
2975 readStream->alloc((void**)&pCounterBuffers,
2976 ((counterBufferCount)) * sizeof(const VkBuffer));
2977 }
2978 if (((counterBufferCount))) {
2979 uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*readStreamPtrPtr);
2980 *readStreamPtrPtr += 8 * ((counterBufferCount));
2981 for (uint32_t k = 0; k < ((counterBufferCount)); ++k) {
2982 uint64_t tmpval;
2983 memcpy(&tmpval, cgen_var_0_0_ptr + k * 8, sizeof(uint64_t));
2984 *(((VkBuffer*)pCounterBuffers) + k) =
2985 (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval);
2986 }
2987 }
2988 }
2989 // WARNING PTR CHECK
2990 memcpy((VkDeviceSize**)&pCounterBufferOffsets, (*readStreamPtrPtr), 8);
2991 android::base::Stream::fromBe64((uint8_t*)&pCounterBufferOffsets);
2992 *readStreamPtrPtr += 8;
2993 if (pCounterBufferOffsets) {
2994 if (((counterBufferCount)) <= MAX_STACK_ITEMS) {
2995 pCounterBufferOffsets = (VkDeviceSize*)stack_pCounterBufferOffsets;
2996 } else {
2997 readStream->alloc((void**)&pCounterBufferOffsets,
2998 ((counterBufferCount)) * sizeof(const VkDeviceSize));
2999 }
3000 memcpy((VkDeviceSize*)pCounterBufferOffsets, *readStreamPtrPtr,
3001 ((counterBufferCount)) * sizeof(const VkDeviceSize));
3002 *readStreamPtrPtr += ((counterBufferCount)) * sizeof(const VkDeviceSize);
3003 }
3004 vk->vkCmdBeginTransformFeedbackEXT((VkCommandBuffer)dispatchHandle,
3005 firstCounterBuffer, counterBufferCount,
3006 pCounterBuffers, pCounterBufferOffsets);
3007 android::base::endTrace();
3008 break;
3009 }
3010 case OP_vkCmdEndTransformFeedbackEXT: {
3011 android::base::beginTrace("vkCmdEndTransformFeedbackEXT subdecode");
3012 uint32_t firstCounterBuffer;
3013 uint32_t counterBufferCount;
3014 const VkBuffer* pCounterBuffers;
3015 VkBuffer stack_pCounterBuffers[MAX_STACK_ITEMS];
3016 const VkDeviceSize* pCounterBufferOffsets;
3017 VkDeviceSize stack_pCounterBufferOffsets[MAX_STACK_ITEMS];
3018 memcpy((uint32_t*)&firstCounterBuffer, *readStreamPtrPtr, sizeof(uint32_t));
3019 *readStreamPtrPtr += sizeof(uint32_t);
3020 memcpy((uint32_t*)&counterBufferCount, *readStreamPtrPtr, sizeof(uint32_t));
3021 *readStreamPtrPtr += sizeof(uint32_t);
3022 // WARNING PTR CHECK
3023 memcpy((VkBuffer**)&pCounterBuffers, (*readStreamPtrPtr), 8);
3024 android::base::Stream::fromBe64((uint8_t*)&pCounterBuffers);
3025 *readStreamPtrPtr += 8;
3026 if (pCounterBuffers) {
3027 if (((counterBufferCount)) <= MAX_STACK_ITEMS) {
3028 pCounterBuffers = (VkBuffer*)stack_pCounterBuffers;
3029 } else {
3030 readStream->alloc((void**)&pCounterBuffers,
3031 ((counterBufferCount)) * sizeof(const VkBuffer));
3032 }
3033 if (((counterBufferCount))) {
3034 uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*readStreamPtrPtr);
3035 *readStreamPtrPtr += 8 * ((counterBufferCount));
3036 for (uint32_t k = 0; k < ((counterBufferCount)); ++k) {
3037 uint64_t tmpval;
3038 memcpy(&tmpval, cgen_var_0_0_ptr + k * 8, sizeof(uint64_t));
3039 *(((VkBuffer*)pCounterBuffers) + k) =
3040 (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval);
3041 }
3042 }
3043 }
3044 // WARNING PTR CHECK
3045 memcpy((VkDeviceSize**)&pCounterBufferOffsets, (*readStreamPtrPtr), 8);
3046 android::base::Stream::fromBe64((uint8_t*)&pCounterBufferOffsets);
3047 *readStreamPtrPtr += 8;
3048 if (pCounterBufferOffsets) {
3049 if (((counterBufferCount)) <= MAX_STACK_ITEMS) {
3050 pCounterBufferOffsets = (VkDeviceSize*)stack_pCounterBufferOffsets;
3051 } else {
3052 readStream->alloc((void**)&pCounterBufferOffsets,
3053 ((counterBufferCount)) * sizeof(const VkDeviceSize));
3054 }
3055 memcpy((VkDeviceSize*)pCounterBufferOffsets, *readStreamPtrPtr,
3056 ((counterBufferCount)) * sizeof(const VkDeviceSize));
3057 *readStreamPtrPtr += ((counterBufferCount)) * sizeof(const VkDeviceSize);
3058 }
3059 vk->vkCmdEndTransformFeedbackEXT((VkCommandBuffer)dispatchHandle,
3060 firstCounterBuffer, counterBufferCount,
3061 pCounterBuffers, pCounterBufferOffsets);
3062 android::base::endTrace();
3063 break;
3064 }
3065 case OP_vkCmdBeginQueryIndexedEXT: {
3066 android::base::beginTrace("vkCmdBeginQueryIndexedEXT subdecode");
3067 VkQueryPool queryPool;
3068 uint32_t query;
3069 VkQueryControlFlags flags;
3070 uint32_t index;
3071 uint64_t cgen_var_0;
3072 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3073 *readStreamPtrPtr += 1 * 8;
3074 *(VkQueryPool*)&queryPool =
3075 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
3076 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
3077 *readStreamPtrPtr += sizeof(uint32_t);
3078 memcpy((VkQueryControlFlags*)&flags, *readStreamPtrPtr,
3079 sizeof(VkQueryControlFlags));
3080 *readStreamPtrPtr += sizeof(VkQueryControlFlags);
3081 memcpy((uint32_t*)&index, *readStreamPtrPtr, sizeof(uint32_t));
3082 *readStreamPtrPtr += sizeof(uint32_t);
3083 vk->vkCmdBeginQueryIndexedEXT((VkCommandBuffer)dispatchHandle, queryPool, query,
3084 flags, index);
3085 android::base::endTrace();
3086 break;
3087 }
3088 case OP_vkCmdEndQueryIndexedEXT: {
3089 android::base::beginTrace("vkCmdEndQueryIndexedEXT subdecode");
3090 VkQueryPool queryPool;
3091 uint32_t query;
3092 uint32_t index;
3093 uint64_t cgen_var_0;
3094 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3095 *readStreamPtrPtr += 1 * 8;
3096 *(VkQueryPool*)&queryPool =
3097 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
3098 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
3099 *readStreamPtrPtr += sizeof(uint32_t);
3100 memcpy((uint32_t*)&index, *readStreamPtrPtr, sizeof(uint32_t));
3101 *readStreamPtrPtr += sizeof(uint32_t);
3102 vk->vkCmdEndQueryIndexedEXT((VkCommandBuffer)dispatchHandle, queryPool, query,
3103 index);
3104 android::base::endTrace();
3105 break;
3106 }
3107 case OP_vkCmdDrawIndirectByteCountEXT: {
3108 android::base::beginTrace("vkCmdDrawIndirectByteCountEXT subdecode");
3109 uint32_t instanceCount;
3110 uint32_t firstInstance;
3111 VkBuffer counterBuffer;
3112 VkDeviceSize counterBufferOffset;
3113 uint32_t counterOffset;
3114 uint32_t vertexStride;
3115 memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
3116 *readStreamPtrPtr += sizeof(uint32_t);
3117 memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
3118 *readStreamPtrPtr += sizeof(uint32_t);
3119 uint64_t cgen_var_0;
3120 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3121 *readStreamPtrPtr += 1 * 8;
3122 *(VkBuffer*)&counterBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
3123 memcpy((VkDeviceSize*)&counterBufferOffset, *readStreamPtrPtr,
3124 sizeof(VkDeviceSize));
3125 *readStreamPtrPtr += sizeof(VkDeviceSize);
3126 memcpy((uint32_t*)&counterOffset, *readStreamPtrPtr, sizeof(uint32_t));
3127 *readStreamPtrPtr += sizeof(uint32_t);
3128 memcpy((uint32_t*)&vertexStride, *readStreamPtrPtr, sizeof(uint32_t));
3129 *readStreamPtrPtr += sizeof(uint32_t);
3130 vk->vkCmdDrawIndirectByteCountEXT((VkCommandBuffer)dispatchHandle, instanceCount,
3131 firstInstance, counterBuffer, counterBufferOffset,
3132 counterOffset, vertexStride);
3133 android::base::endTrace();
3134 break;
3135 }
3136 #endif
3137 #ifdef VK_NVX_binary_import
3138 case OP_vkCmdCuLaunchKernelNVX: {
3139 android::base::beginTrace("vkCmdCuLaunchKernelNVX subdecode");
3140 const VkCuLaunchInfoNVX* pLaunchInfo;
3141 VkCuLaunchInfoNVX stack_pLaunchInfo[1];
3142 pLaunchInfo = (VkCuLaunchInfoNVX*)stack_pLaunchInfo;
3143 reservedunmarshal_VkCuLaunchInfoNVX(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3144 (VkCuLaunchInfoNVX*)(pLaunchInfo),
3145 readStreamPtrPtr);
3146 if (pLaunchInfo) {
3147 transform_tohost_VkCuLaunchInfoNVX(globalstate,
3148 (VkCuLaunchInfoNVX*)(pLaunchInfo));
3149 }
3150 vk->vkCmdCuLaunchKernelNVX((VkCommandBuffer)dispatchHandle, pLaunchInfo);
3151 android::base::endTrace();
3152 break;
3153 }
3154 #endif
3155 #ifdef VK_NVX_image_view_handle
3156 #endif
3157 #ifdef VK_AMD_draw_indirect_count
3158 case OP_vkCmdDrawIndirectCountAMD: {
3159 android::base::beginTrace("vkCmdDrawIndirectCountAMD subdecode");
3160 VkBuffer buffer;
3161 VkDeviceSize offset;
3162 VkBuffer countBuffer;
3163 VkDeviceSize countBufferOffset;
3164 uint32_t maxDrawCount;
3165 uint32_t stride;
3166 uint64_t cgen_var_0;
3167 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3168 *readStreamPtrPtr += 1 * 8;
3169 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
3170 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
3171 *readStreamPtrPtr += sizeof(VkDeviceSize);
3172 uint64_t cgen_var_1;
3173 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3174 *readStreamPtrPtr += 1 * 8;
3175 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
3176 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
3177 *readStreamPtrPtr += sizeof(VkDeviceSize);
3178 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
3179 *readStreamPtrPtr += sizeof(uint32_t);
3180 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
3181 *readStreamPtrPtr += sizeof(uint32_t);
3182 vk->vkCmdDrawIndirectCountAMD((VkCommandBuffer)dispatchHandle, buffer, offset,
3183 countBuffer, countBufferOffset, maxDrawCount, stride);
3184 android::base::endTrace();
3185 break;
3186 }
3187 case OP_vkCmdDrawIndexedIndirectCountAMD: {
3188 android::base::beginTrace("vkCmdDrawIndexedIndirectCountAMD subdecode");
3189 VkBuffer buffer;
3190 VkDeviceSize offset;
3191 VkBuffer countBuffer;
3192 VkDeviceSize countBufferOffset;
3193 uint32_t maxDrawCount;
3194 uint32_t stride;
3195 uint64_t cgen_var_0;
3196 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3197 *readStreamPtrPtr += 1 * 8;
3198 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
3199 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
3200 *readStreamPtrPtr += sizeof(VkDeviceSize);
3201 uint64_t cgen_var_1;
3202 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3203 *readStreamPtrPtr += 1 * 8;
3204 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
3205 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
3206 *readStreamPtrPtr += sizeof(VkDeviceSize);
3207 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
3208 *readStreamPtrPtr += sizeof(uint32_t);
3209 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
3210 *readStreamPtrPtr += sizeof(uint32_t);
3211 vk->vkCmdDrawIndexedIndirectCountAMD((VkCommandBuffer)dispatchHandle, buffer,
3212 offset, countBuffer, countBufferOffset,
3213 maxDrawCount, stride);
3214 android::base::endTrace();
3215 break;
3216 }
3217 #endif
3218 #ifdef VK_AMD_negative_viewport_height
3219 #endif
3220 #ifdef VK_AMD_gpu_shader_half_float
3221 #endif
3222 #ifdef VK_AMD_shader_ballot
3223 #endif
3224 #ifdef VK_EXT_video_encode_h264
3225 #endif
3226 #ifdef VK_EXT_video_encode_h265
3227 #endif
3228 #ifdef VK_AMD_texture_gather_bias_lod
3229 #endif
3230 #ifdef VK_AMD_shader_info
3231 #endif
3232 #ifdef VK_AMD_shader_image_load_store_lod
3233 #endif
3234 #ifdef VK_GGP_stream_descriptor_surface
3235 #endif
3236 #ifdef VK_NV_corner_sampled_image
3237 #endif
3238 #ifdef VK_IMG_format_pvrtc
3239 #endif
3240 #ifdef VK_NV_external_memory_capabilities
3241 #endif
3242 #ifdef VK_NV_external_memory
3243 #endif
3244 #ifdef VK_NV_external_memory_win32
3245 #endif
3246 #ifdef VK_NV_win32_keyed_mutex
3247 #endif
3248 #ifdef VK_EXT_validation_flags
3249 #endif
3250 #ifdef VK_NN_vi_surface
3251 #endif
3252 #ifdef VK_EXT_shader_subgroup_ballot
3253 #endif
3254 #ifdef VK_EXT_shader_subgroup_vote
3255 #endif
3256 #ifdef VK_EXT_texture_compression_astc_hdr
3257 #endif
3258 #ifdef VK_EXT_astc_decode_mode
3259 #endif
3260 #ifdef VK_EXT_pipeline_robustness
3261 #endif
3262 #ifdef VK_EXT_conditional_rendering
3263 case OP_vkCmdBeginConditionalRenderingEXT: {
3264 android::base::beginTrace("vkCmdBeginConditionalRenderingEXT subdecode");
3265 const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin;
3266 VkConditionalRenderingBeginInfoEXT stack_pConditionalRenderingBegin[1];
3267 pConditionalRenderingBegin =
3268 (VkConditionalRenderingBeginInfoEXT*)stack_pConditionalRenderingBegin;
3269 reservedunmarshal_VkConditionalRenderingBeginInfoEXT(
3270 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3271 (VkConditionalRenderingBeginInfoEXT*)(pConditionalRenderingBegin),
3272 readStreamPtrPtr);
3273 if (pConditionalRenderingBegin) {
3274 transform_tohost_VkConditionalRenderingBeginInfoEXT(
3275 globalstate,
3276 (VkConditionalRenderingBeginInfoEXT*)(pConditionalRenderingBegin));
3277 }
3278 vk->vkCmdBeginConditionalRenderingEXT((VkCommandBuffer)dispatchHandle,
3279 pConditionalRenderingBegin);
3280 android::base::endTrace();
3281 break;
3282 }
3283 case OP_vkCmdEndConditionalRenderingEXT: {
3284 android::base::beginTrace("vkCmdEndConditionalRenderingEXT subdecode");
3285 vk->vkCmdEndConditionalRenderingEXT((VkCommandBuffer)dispatchHandle);
3286 android::base::endTrace();
3287 break;
3288 }
3289 #endif
3290 #ifdef VK_NV_clip_space_w_scaling
3291 case OP_vkCmdSetViewportWScalingNV: {
3292 android::base::beginTrace("vkCmdSetViewportWScalingNV subdecode");
3293 uint32_t firstViewport;
3294 uint32_t viewportCount;
3295 const VkViewportWScalingNV* pViewportWScalings;
3296 VkViewportWScalingNV stack_pViewportWScalings[MAX_STACK_ITEMS];
3297 memcpy((uint32_t*)&firstViewport, *readStreamPtrPtr, sizeof(uint32_t));
3298 *readStreamPtrPtr += sizeof(uint32_t);
3299 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
3300 *readStreamPtrPtr += sizeof(uint32_t);
3301 if (((viewportCount)) <= MAX_STACK_ITEMS) {
3302 pViewportWScalings = (VkViewportWScalingNV*)stack_pViewportWScalings;
3303 } else {
3304 readStream->alloc((void**)&pViewportWScalings,
3305 ((viewportCount)) * sizeof(const VkViewportWScalingNV));
3306 }
3307 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
3308 reservedunmarshal_VkViewportWScalingNV(
3309 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3310 (VkViewportWScalingNV*)(pViewportWScalings + i), readStreamPtrPtr);
3311 }
3312 if (pViewportWScalings) {
3313 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
3314 transform_tohost_VkViewportWScalingNV(
3315 globalstate, (VkViewportWScalingNV*)(pViewportWScalings + i));
3316 }
3317 }
3318 vk->vkCmdSetViewportWScalingNV((VkCommandBuffer)dispatchHandle, firstViewport,
3319 viewportCount, pViewportWScalings);
3320 android::base::endTrace();
3321 break;
3322 }
3323 #endif
3324 #ifdef VK_EXT_direct_mode_display
3325 #endif
3326 #ifdef VK_EXT_acquire_xlib_display
3327 #endif
3328 #ifdef VK_EXT_display_surface_counter
3329 #endif
3330 #ifdef VK_EXT_display_control
3331 #endif
3332 #ifdef VK_GOOGLE_display_timing
3333 #endif
3334 #ifdef VK_NV_sample_mask_override_coverage
3335 #endif
3336 #ifdef VK_NV_geometry_shader_passthrough
3337 #endif
3338 #ifdef VK_NV_viewport_array2
3339 #endif
3340 #ifdef VK_NVX_multiview_per_view_attributes
3341 #endif
3342 #ifdef VK_NV_viewport_swizzle
3343 #endif
3344 #ifdef VK_EXT_discard_rectangles
3345 case OP_vkCmdSetDiscardRectangleEXT: {
3346 android::base::beginTrace("vkCmdSetDiscardRectangleEXT subdecode");
3347 uint32_t firstDiscardRectangle;
3348 uint32_t discardRectangleCount;
3349 const VkRect2D* pDiscardRectangles;
3350 VkRect2D stack_pDiscardRectangles[MAX_STACK_ITEMS];
3351 memcpy((uint32_t*)&firstDiscardRectangle, *readStreamPtrPtr, sizeof(uint32_t));
3352 *readStreamPtrPtr += sizeof(uint32_t);
3353 memcpy((uint32_t*)&discardRectangleCount, *readStreamPtrPtr, sizeof(uint32_t));
3354 *readStreamPtrPtr += sizeof(uint32_t);
3355 if (((discardRectangleCount)) <= MAX_STACK_ITEMS) {
3356 pDiscardRectangles = (VkRect2D*)stack_pDiscardRectangles;
3357 } else {
3358 readStream->alloc((void**)&pDiscardRectangles,
3359 ((discardRectangleCount)) * sizeof(const VkRect2D));
3360 }
3361 for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i) {
3362 reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3363 (VkRect2D*)(pDiscardRectangles + i),
3364 readStreamPtrPtr);
3365 }
3366 if (pDiscardRectangles) {
3367 for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i) {
3368 transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pDiscardRectangles + i));
3369 }
3370 }
3371 vk->vkCmdSetDiscardRectangleEXT((VkCommandBuffer)dispatchHandle,
3372 firstDiscardRectangle, discardRectangleCount,
3373 pDiscardRectangles);
3374 android::base::endTrace();
3375 break;
3376 }
3377 case OP_vkCmdSetDiscardRectangleEnableEXT: {
3378 android::base::beginTrace("vkCmdSetDiscardRectangleEnableEXT subdecode");
3379 VkBool32 discardRectangleEnable;
3380 memcpy((VkBool32*)&discardRectangleEnable, *readStreamPtrPtr, sizeof(VkBool32));
3381 *readStreamPtrPtr += sizeof(VkBool32);
3382 vk->vkCmdSetDiscardRectangleEnableEXT((VkCommandBuffer)dispatchHandle,
3383 discardRectangleEnable);
3384 android::base::endTrace();
3385 break;
3386 }
3387 case OP_vkCmdSetDiscardRectangleModeEXT: {
3388 android::base::beginTrace("vkCmdSetDiscardRectangleModeEXT subdecode");
3389 VkDiscardRectangleModeEXT discardRectangleMode;
3390 memcpy((VkDiscardRectangleModeEXT*)&discardRectangleMode, *readStreamPtrPtr,
3391 sizeof(VkDiscardRectangleModeEXT));
3392 *readStreamPtrPtr += sizeof(VkDiscardRectangleModeEXT);
3393 vk->vkCmdSetDiscardRectangleModeEXT((VkCommandBuffer)dispatchHandle,
3394 discardRectangleMode);
3395 android::base::endTrace();
3396 break;
3397 }
3398 #endif
3399 #ifdef VK_EXT_conservative_rasterization
3400 #endif
3401 #ifdef VK_EXT_depth_clip_enable
3402 #endif
3403 #ifdef VK_EXT_swapchain_colorspace
3404 #endif
3405 #ifdef VK_EXT_hdr_metadata
3406 #endif
3407 #ifdef VK_MVK_ios_surface
3408 #endif
3409 #ifdef VK_MVK_macos_surface
3410 #endif
3411 #ifdef VK_EXT_external_memory_dma_buf
3412 #endif
3413 #ifdef VK_EXT_queue_family_foreign
3414 #endif
3415 #ifdef VK_EXT_debug_utils
3416 case OP_vkCmdBeginDebugUtilsLabelEXT: {
3417 android::base::beginTrace("vkCmdBeginDebugUtilsLabelEXT subdecode");
3418 const VkDebugUtilsLabelEXT* pLabelInfo;
3419 VkDebugUtilsLabelEXT stack_pLabelInfo[1];
3420 pLabelInfo = (VkDebugUtilsLabelEXT*)stack_pLabelInfo;
3421 reservedunmarshal_VkDebugUtilsLabelEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3422 (VkDebugUtilsLabelEXT*)(pLabelInfo),
3423 readStreamPtrPtr);
3424 if (pLabelInfo) {
3425 transform_tohost_VkDebugUtilsLabelEXT(globalstate,
3426 (VkDebugUtilsLabelEXT*)(pLabelInfo));
3427 }
3428 vk->vkCmdBeginDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle, pLabelInfo);
3429 android::base::endTrace();
3430 break;
3431 }
3432 case OP_vkCmdEndDebugUtilsLabelEXT: {
3433 android::base::beginTrace("vkCmdEndDebugUtilsLabelEXT subdecode");
3434 vk->vkCmdEndDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle);
3435 android::base::endTrace();
3436 break;
3437 }
3438 case OP_vkCmdInsertDebugUtilsLabelEXT: {
3439 android::base::beginTrace("vkCmdInsertDebugUtilsLabelEXT subdecode");
3440 const VkDebugUtilsLabelEXT* pLabelInfo;
3441 VkDebugUtilsLabelEXT stack_pLabelInfo[1];
3442 pLabelInfo = (VkDebugUtilsLabelEXT*)stack_pLabelInfo;
3443 reservedunmarshal_VkDebugUtilsLabelEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3444 (VkDebugUtilsLabelEXT*)(pLabelInfo),
3445 readStreamPtrPtr);
3446 if (pLabelInfo) {
3447 transform_tohost_VkDebugUtilsLabelEXT(globalstate,
3448 (VkDebugUtilsLabelEXT*)(pLabelInfo));
3449 }
3450 vk->vkCmdInsertDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle, pLabelInfo);
3451 android::base::endTrace();
3452 break;
3453 }
3454 #endif
3455 #ifdef VK_ANDROID_external_memory_android_hardware_buffer
3456 #endif
3457 #ifdef VK_EXT_sampler_filter_minmax
3458 #endif
3459 #ifdef VK_AMD_gpu_shader_int16
3460 #endif
3461 #ifdef VK_AMD_mixed_attachment_samples
3462 #endif
3463 #ifdef VK_AMD_shader_fragment_mask
3464 #endif
3465 #ifdef VK_EXT_inline_uniform_block
3466 #endif
3467 #ifdef VK_EXT_shader_stencil_export
3468 #endif
3469 #ifdef VK_EXT_sample_locations
3470 case OP_vkCmdSetSampleLocationsEXT: {
3471 android::base::beginTrace("vkCmdSetSampleLocationsEXT subdecode");
3472 const VkSampleLocationsInfoEXT* pSampleLocationsInfo;
3473 VkSampleLocationsInfoEXT stack_pSampleLocationsInfo[1];
3474 pSampleLocationsInfo = (VkSampleLocationsInfoEXT*)stack_pSampleLocationsInfo;
3475 reservedunmarshal_VkSampleLocationsInfoEXT(
3476 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3477 (VkSampleLocationsInfoEXT*)(pSampleLocationsInfo), readStreamPtrPtr);
3478 if (pSampleLocationsInfo) {
3479 transform_tohost_VkSampleLocationsInfoEXT(
3480 globalstate, (VkSampleLocationsInfoEXT*)(pSampleLocationsInfo));
3481 }
3482 vk->vkCmdSetSampleLocationsEXT((VkCommandBuffer)dispatchHandle,
3483 pSampleLocationsInfo);
3484 android::base::endTrace();
3485 break;
3486 }
3487 #endif
3488 #ifdef VK_EXT_blend_operation_advanced
3489 #endif
3490 #ifdef VK_NV_fragment_coverage_to_color
3491 #endif
3492 #ifdef VK_NV_framebuffer_mixed_samples
3493 #endif
3494 #ifdef VK_NV_fill_rectangle
3495 #endif
3496 #ifdef VK_NV_shader_sm_builtins
3497 #endif
3498 #ifdef VK_EXT_post_depth_coverage
3499 #endif
3500 #ifdef VK_EXT_image_drm_format_modifier
3501 #endif
3502 #ifdef VK_EXT_validation_cache
3503 #endif
3504 #ifdef VK_EXT_descriptor_indexing
3505 #endif
3506 #ifdef VK_EXT_shader_viewport_index_layer
3507 #endif
3508 #ifdef VK_NV_shading_rate_image
3509 case OP_vkCmdBindShadingRateImageNV: {
3510 android::base::beginTrace("vkCmdBindShadingRateImageNV subdecode");
3511 VkImageView imageView;
3512 VkImageLayout imageLayout;
3513 uint64_t cgen_var_0;
3514 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3515 *readStreamPtrPtr += 1 * 8;
3516 *(VkImageView*)&imageView =
3517 (VkImageView)unbox_VkImageView((VkImageView)(*&cgen_var_0));
3518 memcpy((VkImageLayout*)&imageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
3519 *readStreamPtrPtr += sizeof(VkImageLayout);
3520 vk->vkCmdBindShadingRateImageNV((VkCommandBuffer)dispatchHandle, imageView,
3521 imageLayout);
3522 android::base::endTrace();
3523 break;
3524 }
3525 case OP_vkCmdSetViewportShadingRatePaletteNV: {
3526 android::base::beginTrace("vkCmdSetViewportShadingRatePaletteNV subdecode");
3527 uint32_t firstViewport;
3528 uint32_t viewportCount;
3529 const VkShadingRatePaletteNV* pShadingRatePalettes;
3530 VkShadingRatePaletteNV stack_pShadingRatePalettes[MAX_STACK_ITEMS];
3531 memcpy((uint32_t*)&firstViewport, *readStreamPtrPtr, sizeof(uint32_t));
3532 *readStreamPtrPtr += sizeof(uint32_t);
3533 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
3534 *readStreamPtrPtr += sizeof(uint32_t);
3535 if (((viewportCount)) <= MAX_STACK_ITEMS) {
3536 pShadingRatePalettes = (VkShadingRatePaletteNV*)stack_pShadingRatePalettes;
3537 } else {
3538 readStream->alloc((void**)&pShadingRatePalettes,
3539 ((viewportCount)) * sizeof(const VkShadingRatePaletteNV));
3540 }
3541 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
3542 reservedunmarshal_VkShadingRatePaletteNV(
3543 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3544 (VkShadingRatePaletteNV*)(pShadingRatePalettes + i), readStreamPtrPtr);
3545 }
3546 if (pShadingRatePalettes) {
3547 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
3548 transform_tohost_VkShadingRatePaletteNV(
3549 globalstate, (VkShadingRatePaletteNV*)(pShadingRatePalettes + i));
3550 }
3551 }
3552 vk->vkCmdSetViewportShadingRatePaletteNV((VkCommandBuffer)dispatchHandle,
3553 firstViewport, viewportCount,
3554 pShadingRatePalettes);
3555 android::base::endTrace();
3556 break;
3557 }
3558 case OP_vkCmdSetCoarseSampleOrderNV: {
3559 android::base::beginTrace("vkCmdSetCoarseSampleOrderNV subdecode");
3560 VkCoarseSampleOrderTypeNV sampleOrderType;
3561 uint32_t customSampleOrderCount;
3562 const VkCoarseSampleOrderCustomNV* pCustomSampleOrders;
3563 VkCoarseSampleOrderCustomNV stack_pCustomSampleOrders[MAX_STACK_ITEMS];
3564 memcpy((VkCoarseSampleOrderTypeNV*)&sampleOrderType, *readStreamPtrPtr,
3565 sizeof(VkCoarseSampleOrderTypeNV));
3566 *readStreamPtrPtr += sizeof(VkCoarseSampleOrderTypeNV);
3567 memcpy((uint32_t*)&customSampleOrderCount, *readStreamPtrPtr, sizeof(uint32_t));
3568 *readStreamPtrPtr += sizeof(uint32_t);
3569 if (((customSampleOrderCount)) <= MAX_STACK_ITEMS) {
3570 pCustomSampleOrders = (VkCoarseSampleOrderCustomNV*)stack_pCustomSampleOrders;
3571 } else {
3572 readStream->alloc(
3573 (void**)&pCustomSampleOrders,
3574 ((customSampleOrderCount)) * sizeof(const VkCoarseSampleOrderCustomNV));
3575 }
3576 for (uint32_t i = 0; i < (uint32_t)((customSampleOrderCount)); ++i) {
3577 reservedunmarshal_VkCoarseSampleOrderCustomNV(
3578 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3579 (VkCoarseSampleOrderCustomNV*)(pCustomSampleOrders + i), readStreamPtrPtr);
3580 }
3581 if (pCustomSampleOrders) {
3582 for (uint32_t i = 0; i < (uint32_t)((customSampleOrderCount)); ++i) {
3583 transform_tohost_VkCoarseSampleOrderCustomNV(
3584 globalstate, (VkCoarseSampleOrderCustomNV*)(pCustomSampleOrders + i));
3585 }
3586 }
3587 vk->vkCmdSetCoarseSampleOrderNV((VkCommandBuffer)dispatchHandle, sampleOrderType,
3588 customSampleOrderCount, pCustomSampleOrders);
3589 android::base::endTrace();
3590 break;
3591 }
3592 #endif
3593 #ifdef VK_NV_ray_tracing
3594 case OP_vkCmdBuildAccelerationStructureNV: {
3595 android::base::beginTrace("vkCmdBuildAccelerationStructureNV subdecode");
3596 const VkAccelerationStructureInfoNV* pInfo;
3597 VkAccelerationStructureInfoNV stack_pInfo[1];
3598 VkBuffer instanceData;
3599 VkDeviceSize instanceOffset;
3600 VkBool32 update;
3601 VkAccelerationStructureNV dst;
3602 VkAccelerationStructureNV src;
3603 VkBuffer scratch;
3604 VkDeviceSize scratchOffset;
3605 pInfo = (VkAccelerationStructureInfoNV*)stack_pInfo;
3606 reservedunmarshal_VkAccelerationStructureInfoNV(
3607 readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureInfoNV*)(pInfo),
3608 readStreamPtrPtr);
3609 uint64_t cgen_var_0;
3610 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3611 *readStreamPtrPtr += 1 * 8;
3612 *(VkBuffer*)&instanceData = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
3613 memcpy((VkDeviceSize*)&instanceOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
3614 *readStreamPtrPtr += sizeof(VkDeviceSize);
3615 memcpy((VkBool32*)&update, *readStreamPtrPtr, sizeof(VkBool32));
3616 *readStreamPtrPtr += sizeof(VkBool32);
3617 uint64_t cgen_var_1;
3618 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3619 *readStreamPtrPtr += 1 * 8;
3620 *(VkAccelerationStructureNV*)&dst =
3621 (VkAccelerationStructureNV)unbox_VkAccelerationStructureNV(
3622 (VkAccelerationStructureNV)(*&cgen_var_1));
3623 uint64_t cgen_var_2;
3624 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
3625 *readStreamPtrPtr += 1 * 8;
3626 *(VkAccelerationStructureNV*)&src =
3627 (VkAccelerationStructureNV)unbox_VkAccelerationStructureNV(
3628 (VkAccelerationStructureNV)(*&cgen_var_2));
3629 uint64_t cgen_var_3;
3630 memcpy((uint64_t*)&cgen_var_3, *readStreamPtrPtr, 1 * 8);
3631 *readStreamPtrPtr += 1 * 8;
3632 *(VkBuffer*)&scratch = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_3));
3633 memcpy((VkDeviceSize*)&scratchOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
3634 *readStreamPtrPtr += sizeof(VkDeviceSize);
3635 if (pInfo) {
3636 transform_tohost_VkAccelerationStructureInfoNV(
3637 globalstate, (VkAccelerationStructureInfoNV*)(pInfo));
3638 }
3639 vk->vkCmdBuildAccelerationStructureNV((VkCommandBuffer)dispatchHandle, pInfo,
3640 instanceData, instanceOffset, update, dst,
3641 src, scratch, scratchOffset);
3642 android::base::endTrace();
3643 break;
3644 }
3645 case OP_vkCmdCopyAccelerationStructureNV: {
3646 android::base::beginTrace("vkCmdCopyAccelerationStructureNV subdecode");
3647 VkAccelerationStructureNV dst;
3648 VkAccelerationStructureNV src;
3649 VkCopyAccelerationStructureModeKHR mode;
3650 uint64_t cgen_var_0;
3651 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3652 *readStreamPtrPtr += 1 * 8;
3653 *(VkAccelerationStructureNV*)&dst =
3654 (VkAccelerationStructureNV)unbox_VkAccelerationStructureNV(
3655 (VkAccelerationStructureNV)(*&cgen_var_0));
3656 uint64_t cgen_var_1;
3657 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3658 *readStreamPtrPtr += 1 * 8;
3659 *(VkAccelerationStructureNV*)&src =
3660 (VkAccelerationStructureNV)unbox_VkAccelerationStructureNV(
3661 (VkAccelerationStructureNV)(*&cgen_var_1));
3662 memcpy((VkCopyAccelerationStructureModeKHR*)&mode, *readStreamPtrPtr,
3663 sizeof(VkCopyAccelerationStructureModeKHR));
3664 *readStreamPtrPtr += sizeof(VkCopyAccelerationStructureModeKHR);
3665 vk->vkCmdCopyAccelerationStructureNV((VkCommandBuffer)dispatchHandle, dst, src,
3666 mode);
3667 android::base::endTrace();
3668 break;
3669 }
3670 case OP_vkCmdTraceRaysNV: {
3671 android::base::beginTrace("vkCmdTraceRaysNV subdecode");
3672 VkBuffer raygenShaderBindingTableBuffer;
3673 VkDeviceSize raygenShaderBindingOffset;
3674 VkBuffer missShaderBindingTableBuffer;
3675 VkDeviceSize missShaderBindingOffset;
3676 VkDeviceSize missShaderBindingStride;
3677 VkBuffer hitShaderBindingTableBuffer;
3678 VkDeviceSize hitShaderBindingOffset;
3679 VkDeviceSize hitShaderBindingStride;
3680 VkBuffer callableShaderBindingTableBuffer;
3681 VkDeviceSize callableShaderBindingOffset;
3682 VkDeviceSize callableShaderBindingStride;
3683 uint32_t width;
3684 uint32_t height;
3685 uint32_t depth;
3686 uint64_t cgen_var_0;
3687 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3688 *readStreamPtrPtr += 1 * 8;
3689 *(VkBuffer*)&raygenShaderBindingTableBuffer =
3690 (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
3691 memcpy((VkDeviceSize*)&raygenShaderBindingOffset, *readStreamPtrPtr,
3692 sizeof(VkDeviceSize));
3693 *readStreamPtrPtr += sizeof(VkDeviceSize);
3694 uint64_t cgen_var_1;
3695 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3696 *readStreamPtrPtr += 1 * 8;
3697 *(VkBuffer*)&missShaderBindingTableBuffer =
3698 (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
3699 memcpy((VkDeviceSize*)&missShaderBindingOffset, *readStreamPtrPtr,
3700 sizeof(VkDeviceSize));
3701 *readStreamPtrPtr += sizeof(VkDeviceSize);
3702 memcpy((VkDeviceSize*)&missShaderBindingStride, *readStreamPtrPtr,
3703 sizeof(VkDeviceSize));
3704 *readStreamPtrPtr += sizeof(VkDeviceSize);
3705 uint64_t cgen_var_2;
3706 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
3707 *readStreamPtrPtr += 1 * 8;
3708 *(VkBuffer*)&hitShaderBindingTableBuffer =
3709 (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_2));
3710 memcpy((VkDeviceSize*)&hitShaderBindingOffset, *readStreamPtrPtr,
3711 sizeof(VkDeviceSize));
3712 *readStreamPtrPtr += sizeof(VkDeviceSize);
3713 memcpy((VkDeviceSize*)&hitShaderBindingStride, *readStreamPtrPtr,
3714 sizeof(VkDeviceSize));
3715 *readStreamPtrPtr += sizeof(VkDeviceSize);
3716 uint64_t cgen_var_3;
3717 memcpy((uint64_t*)&cgen_var_3, *readStreamPtrPtr, 1 * 8);
3718 *readStreamPtrPtr += 1 * 8;
3719 *(VkBuffer*)&callableShaderBindingTableBuffer =
3720 (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_3));
3721 memcpy((VkDeviceSize*)&callableShaderBindingOffset, *readStreamPtrPtr,
3722 sizeof(VkDeviceSize));
3723 *readStreamPtrPtr += sizeof(VkDeviceSize);
3724 memcpy((VkDeviceSize*)&callableShaderBindingStride, *readStreamPtrPtr,
3725 sizeof(VkDeviceSize));
3726 *readStreamPtrPtr += sizeof(VkDeviceSize);
3727 memcpy((uint32_t*)&width, *readStreamPtrPtr, sizeof(uint32_t));
3728 *readStreamPtrPtr += sizeof(uint32_t);
3729 memcpy((uint32_t*)&height, *readStreamPtrPtr, sizeof(uint32_t));
3730 *readStreamPtrPtr += sizeof(uint32_t);
3731 memcpy((uint32_t*)&depth, *readStreamPtrPtr, sizeof(uint32_t));
3732 *readStreamPtrPtr += sizeof(uint32_t);
3733 vk->vkCmdTraceRaysNV((VkCommandBuffer)dispatchHandle,
3734 raygenShaderBindingTableBuffer, raygenShaderBindingOffset,
3735 missShaderBindingTableBuffer, missShaderBindingOffset,
3736 missShaderBindingStride, hitShaderBindingTableBuffer,
3737 hitShaderBindingOffset, hitShaderBindingStride,
3738 callableShaderBindingTableBuffer, callableShaderBindingOffset,
3739 callableShaderBindingStride, width, height, depth);
3740 android::base::endTrace();
3741 break;
3742 }
3743 case OP_vkCmdWriteAccelerationStructuresPropertiesNV: {
3744 android::base::beginTrace("vkCmdWriteAccelerationStructuresPropertiesNV subdecode");
3745 uint32_t accelerationStructureCount;
3746 const VkAccelerationStructureNV* pAccelerationStructures;
3747 VkAccelerationStructureNV stack_pAccelerationStructures[MAX_STACK_ITEMS];
3748 VkQueryType queryType;
3749 VkQueryPool queryPool;
3750 uint32_t firstQuery;
3751 memcpy((uint32_t*)&accelerationStructureCount, *readStreamPtrPtr, sizeof(uint32_t));
3752 *readStreamPtrPtr += sizeof(uint32_t);
3753 if (((accelerationStructureCount)) <= MAX_STACK_ITEMS) {
3754 pAccelerationStructures =
3755 (VkAccelerationStructureNV*)stack_pAccelerationStructures;
3756 } else {
3757 readStream->alloc(
3758 (void**)&pAccelerationStructures,
3759 ((accelerationStructureCount)) * sizeof(const VkAccelerationStructureNV));
3760 }
3761 if (((accelerationStructureCount))) {
3762 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
3763 *readStreamPtrPtr += 8 * ((accelerationStructureCount));
3764 for (uint32_t k = 0; k < ((accelerationStructureCount)); ++k) {
3765 uint64_t tmpval;
3766 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
3767 *(((VkAccelerationStructureNV*)pAccelerationStructures) + k) =
3768 (VkAccelerationStructureNV)unbox_VkAccelerationStructureNV(
3769 (VkAccelerationStructureNV)tmpval);
3770 }
3771 }
3772 memcpy((VkQueryType*)&queryType, *readStreamPtrPtr, sizeof(VkQueryType));
3773 *readStreamPtrPtr += sizeof(VkQueryType);
3774 uint64_t cgen_var_1;
3775 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3776 *readStreamPtrPtr += 1 * 8;
3777 *(VkQueryPool*)&queryPool =
3778 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
3779 memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
3780 *readStreamPtrPtr += sizeof(uint32_t);
3781 vk->vkCmdWriteAccelerationStructuresPropertiesNV(
3782 (VkCommandBuffer)dispatchHandle, accelerationStructureCount,
3783 pAccelerationStructures, queryType, queryPool, firstQuery);
3784 android::base::endTrace();
3785 break;
3786 }
3787 #endif
3788 #ifdef VK_NV_representative_fragment_test
3789 #endif
3790 #ifdef VK_EXT_filter_cubic
3791 #endif
3792 #ifdef VK_QCOM_render_pass_shader_resolve
3793 #endif
3794 #ifdef VK_EXT_global_priority
3795 #endif
3796 #ifdef VK_EXT_external_memory_host
3797 #endif
3798 #ifdef VK_AMD_buffer_marker
3799 case OP_vkCmdWriteBufferMarkerAMD: {
3800 android::base::beginTrace("vkCmdWriteBufferMarkerAMD subdecode");
3801 VkPipelineStageFlagBits pipelineStage;
3802 VkBuffer dstBuffer;
3803 VkDeviceSize dstOffset;
3804 uint32_t marker;
3805 memcpy((VkPipelineStageFlagBits*)&pipelineStage, *readStreamPtrPtr,
3806 sizeof(VkPipelineStageFlagBits));
3807 *readStreamPtrPtr += sizeof(VkPipelineStageFlagBits);
3808 uint64_t cgen_var_0;
3809 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3810 *readStreamPtrPtr += 1 * 8;
3811 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
3812 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
3813 *readStreamPtrPtr += sizeof(VkDeviceSize);
3814 memcpy((uint32_t*)&marker, *readStreamPtrPtr, sizeof(uint32_t));
3815 *readStreamPtrPtr += sizeof(uint32_t);
3816 vk->vkCmdWriteBufferMarkerAMD((VkCommandBuffer)dispatchHandle, pipelineStage,
3817 dstBuffer, dstOffset, marker);
3818 android::base::endTrace();
3819 break;
3820 }
3821 #endif
3822 #ifdef VK_AMD_pipeline_compiler_control
3823 #endif
3824 #ifdef VK_EXT_calibrated_timestamps
3825 #endif
3826 #ifdef VK_AMD_shader_core_properties
3827 #endif
3828 #ifdef VK_AMD_memory_overallocation_behavior
3829 #endif
3830 #ifdef VK_EXT_vertex_attribute_divisor
3831 #endif
3832 #ifdef VK_GGP_frame_token
3833 #endif
3834 #ifdef VK_EXT_pipeline_creation_feedback
3835 #endif
3836 #ifdef VK_NV_shader_subgroup_partitioned
3837 #endif
3838 #ifdef VK_NV_compute_shader_derivatives
3839 #endif
3840 #ifdef VK_NV_mesh_shader
3841 case OP_vkCmdDrawMeshTasksNV: {
3842 android::base::beginTrace("vkCmdDrawMeshTasksNV subdecode");
3843 uint32_t taskCount;
3844 uint32_t firstTask;
3845 memcpy((uint32_t*)&taskCount, *readStreamPtrPtr, sizeof(uint32_t));
3846 *readStreamPtrPtr += sizeof(uint32_t);
3847 memcpy((uint32_t*)&firstTask, *readStreamPtrPtr, sizeof(uint32_t));
3848 *readStreamPtrPtr += sizeof(uint32_t);
3849 vk->vkCmdDrawMeshTasksNV((VkCommandBuffer)dispatchHandle, taskCount, firstTask);
3850 android::base::endTrace();
3851 break;
3852 }
3853 case OP_vkCmdDrawMeshTasksIndirectNV: {
3854 android::base::beginTrace("vkCmdDrawMeshTasksIndirectNV subdecode");
3855 VkBuffer buffer;
3856 VkDeviceSize offset;
3857 uint32_t drawCount;
3858 uint32_t stride;
3859 uint64_t cgen_var_0;
3860 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3861 *readStreamPtrPtr += 1 * 8;
3862 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
3863 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
3864 *readStreamPtrPtr += sizeof(VkDeviceSize);
3865 memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
3866 *readStreamPtrPtr += sizeof(uint32_t);
3867 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
3868 *readStreamPtrPtr += sizeof(uint32_t);
3869 vk->vkCmdDrawMeshTasksIndirectNV((VkCommandBuffer)dispatchHandle, buffer, offset,
3870 drawCount, stride);
3871 android::base::endTrace();
3872 break;
3873 }
3874 case OP_vkCmdDrawMeshTasksIndirectCountNV: {
3875 android::base::beginTrace("vkCmdDrawMeshTasksIndirectCountNV subdecode");
3876 VkBuffer buffer;
3877 VkDeviceSize offset;
3878 VkBuffer countBuffer;
3879 VkDeviceSize countBufferOffset;
3880 uint32_t maxDrawCount;
3881 uint32_t stride;
3882 uint64_t cgen_var_0;
3883 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3884 *readStreamPtrPtr += 1 * 8;
3885 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
3886 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
3887 *readStreamPtrPtr += sizeof(VkDeviceSize);
3888 uint64_t cgen_var_1;
3889 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3890 *readStreamPtrPtr += 1 * 8;
3891 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
3892 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
3893 *readStreamPtrPtr += sizeof(VkDeviceSize);
3894 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
3895 *readStreamPtrPtr += sizeof(uint32_t);
3896 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
3897 *readStreamPtrPtr += sizeof(uint32_t);
3898 vk->vkCmdDrawMeshTasksIndirectCountNV((VkCommandBuffer)dispatchHandle, buffer,
3899 offset, countBuffer, countBufferOffset,
3900 maxDrawCount, stride);
3901 android::base::endTrace();
3902 break;
3903 }
3904 #endif
3905 #ifdef VK_NV_fragment_shader_barycentric
3906 #endif
3907 #ifdef VK_NV_shader_image_footprint
3908 #endif
3909 #ifdef VK_NV_scissor_exclusive
3910 case OP_vkCmdSetExclusiveScissorEnableNV: {
3911 android::base::beginTrace("vkCmdSetExclusiveScissorEnableNV subdecode");
3912 uint32_t firstExclusiveScissor;
3913 uint32_t exclusiveScissorCount;
3914 const VkBool32* pExclusiveScissorEnables;
3915 VkBool32 stack_pExclusiveScissorEnables[MAX_STACK_ITEMS];
3916 memcpy((uint32_t*)&firstExclusiveScissor, *readStreamPtrPtr, sizeof(uint32_t));
3917 *readStreamPtrPtr += sizeof(uint32_t);
3918 memcpy((uint32_t*)&exclusiveScissorCount, *readStreamPtrPtr, sizeof(uint32_t));
3919 *readStreamPtrPtr += sizeof(uint32_t);
3920 if (((exclusiveScissorCount)) <= MAX_STACK_ITEMS) {
3921 pExclusiveScissorEnables = (VkBool32*)stack_pExclusiveScissorEnables;
3922 } else {
3923 readStream->alloc((void**)&pExclusiveScissorEnables,
3924 ((exclusiveScissorCount)) * sizeof(const VkBool32));
3925 }
3926 memcpy((VkBool32*)pExclusiveScissorEnables, *readStreamPtrPtr,
3927 ((exclusiveScissorCount)) * sizeof(const VkBool32));
3928 *readStreamPtrPtr += ((exclusiveScissorCount)) * sizeof(const VkBool32);
3929 vk->vkCmdSetExclusiveScissorEnableNV((VkCommandBuffer)dispatchHandle,
3930 firstExclusiveScissor, exclusiveScissorCount,
3931 pExclusiveScissorEnables);
3932 android::base::endTrace();
3933 break;
3934 }
3935 case OP_vkCmdSetExclusiveScissorNV: {
3936 android::base::beginTrace("vkCmdSetExclusiveScissorNV subdecode");
3937 uint32_t firstExclusiveScissor;
3938 uint32_t exclusiveScissorCount;
3939 const VkRect2D* pExclusiveScissors;
3940 VkRect2D stack_pExclusiveScissors[MAX_STACK_ITEMS];
3941 memcpy((uint32_t*)&firstExclusiveScissor, *readStreamPtrPtr, sizeof(uint32_t));
3942 *readStreamPtrPtr += sizeof(uint32_t);
3943 memcpy((uint32_t*)&exclusiveScissorCount, *readStreamPtrPtr, sizeof(uint32_t));
3944 *readStreamPtrPtr += sizeof(uint32_t);
3945 if (((exclusiveScissorCount)) <= MAX_STACK_ITEMS) {
3946 pExclusiveScissors = (VkRect2D*)stack_pExclusiveScissors;
3947 } else {
3948 readStream->alloc((void**)&pExclusiveScissors,
3949 ((exclusiveScissorCount)) * sizeof(const VkRect2D));
3950 }
3951 for (uint32_t i = 0; i < (uint32_t)((exclusiveScissorCount)); ++i) {
3952 reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3953 (VkRect2D*)(pExclusiveScissors + i),
3954 readStreamPtrPtr);
3955 }
3956 if (pExclusiveScissors) {
3957 for (uint32_t i = 0; i < (uint32_t)((exclusiveScissorCount)); ++i) {
3958 transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pExclusiveScissors + i));
3959 }
3960 }
3961 vk->vkCmdSetExclusiveScissorNV((VkCommandBuffer)dispatchHandle,
3962 firstExclusiveScissor, exclusiveScissorCount,
3963 pExclusiveScissors);
3964 android::base::endTrace();
3965 break;
3966 }
3967 #endif
3968 #ifdef VK_NV_device_diagnostic_checkpoints
3969 case OP_vkCmdSetCheckpointNV: {
3970 android::base::beginTrace("vkCmdSetCheckpointNV subdecode");
3971 const void* pCheckpointMarker;
3972 uint8_t* stack_pCheckpointMarker[1];
3973 // WARNING PTR CHECK
3974 memcpy((void**)&pCheckpointMarker, (*readStreamPtrPtr), 8);
3975 android::base::Stream::fromBe64((uint8_t*)&pCheckpointMarker);
3976 *readStreamPtrPtr += 8;
3977 if (pCheckpointMarker) {
3978 pCheckpointMarker = (void*)stack_pCheckpointMarker;
3979 memcpy((void*)pCheckpointMarker, *readStreamPtrPtr, sizeof(const uint8_t));
3980 *readStreamPtrPtr += sizeof(const uint8_t);
3981 }
3982 vk->vkCmdSetCheckpointNV((VkCommandBuffer)dispatchHandle, pCheckpointMarker);
3983 android::base::endTrace();
3984 break;
3985 }
3986 #endif
3987 #ifdef VK_INTEL_shader_integer_functions2
3988 #endif
3989 #ifdef VK_INTEL_performance_query
3990 case OP_vkCmdSetPerformanceMarkerINTEL: {
3991 android::base::beginTrace("vkCmdSetPerformanceMarkerINTEL subdecode");
3992 const VkPerformanceMarkerInfoINTEL* pMarkerInfo;
3993 VkPerformanceMarkerInfoINTEL stack_pMarkerInfo[1];
3994 pMarkerInfo = (VkPerformanceMarkerInfoINTEL*)stack_pMarkerInfo;
3995 reservedunmarshal_VkPerformanceMarkerInfoINTEL(
3996 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3997 (VkPerformanceMarkerInfoINTEL*)(pMarkerInfo), readStreamPtrPtr);
3998 if (pMarkerInfo) {
3999 transform_tohost_VkPerformanceMarkerInfoINTEL(
4000 globalstate, (VkPerformanceMarkerInfoINTEL*)(pMarkerInfo));
4001 }
4002 VkResult vkCmdSetPerformanceMarkerINTEL_VkResult_return = (VkResult)0;
4003 vkCmdSetPerformanceMarkerINTEL_VkResult_return = vk->vkCmdSetPerformanceMarkerINTEL(
4004 (VkCommandBuffer)dispatchHandle, pMarkerInfo);
4005 if ((vkCmdSetPerformanceMarkerINTEL_VkResult_return) == VK_ERROR_DEVICE_LOST)
4006 this->on_DeviceLost();
4007 this->on_CheckOutOfMemory(vkCmdSetPerformanceMarkerINTEL_VkResult_return, opcode,
4008 context);
4009 android::base::endTrace();
4010 break;
4011 }
4012 case OP_vkCmdSetPerformanceStreamMarkerINTEL: {
4013 android::base::beginTrace("vkCmdSetPerformanceStreamMarkerINTEL subdecode");
4014 const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo;
4015 VkPerformanceStreamMarkerInfoINTEL stack_pMarkerInfo[1];
4016 pMarkerInfo = (VkPerformanceStreamMarkerInfoINTEL*)stack_pMarkerInfo;
4017 reservedunmarshal_VkPerformanceStreamMarkerInfoINTEL(
4018 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4019 (VkPerformanceStreamMarkerInfoINTEL*)(pMarkerInfo), readStreamPtrPtr);
4020 if (pMarkerInfo) {
4021 transform_tohost_VkPerformanceStreamMarkerInfoINTEL(
4022 globalstate, (VkPerformanceStreamMarkerInfoINTEL*)(pMarkerInfo));
4023 }
4024 VkResult vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return = (VkResult)0;
4025 vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return =
4026 vk->vkCmdSetPerformanceStreamMarkerINTEL((VkCommandBuffer)dispatchHandle,
4027 pMarkerInfo);
4028 if ((vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return) == VK_ERROR_DEVICE_LOST)
4029 this->on_DeviceLost();
4030 this->on_CheckOutOfMemory(vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return,
4031 opcode, context);
4032 android::base::endTrace();
4033 break;
4034 }
4035 case OP_vkCmdSetPerformanceOverrideINTEL: {
4036 android::base::beginTrace("vkCmdSetPerformanceOverrideINTEL subdecode");
4037 const VkPerformanceOverrideInfoINTEL* pOverrideInfo;
4038 VkPerformanceOverrideInfoINTEL stack_pOverrideInfo[1];
4039 pOverrideInfo = (VkPerformanceOverrideInfoINTEL*)stack_pOverrideInfo;
4040 reservedunmarshal_VkPerformanceOverrideInfoINTEL(
4041 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4042 (VkPerformanceOverrideInfoINTEL*)(pOverrideInfo), readStreamPtrPtr);
4043 if (pOverrideInfo) {
4044 transform_tohost_VkPerformanceOverrideInfoINTEL(
4045 globalstate, (VkPerformanceOverrideInfoINTEL*)(pOverrideInfo));
4046 }
4047 VkResult vkCmdSetPerformanceOverrideINTEL_VkResult_return = (VkResult)0;
4048 vkCmdSetPerformanceOverrideINTEL_VkResult_return =
4049 vk->vkCmdSetPerformanceOverrideINTEL((VkCommandBuffer)dispatchHandle,
4050 pOverrideInfo);
4051 if ((vkCmdSetPerformanceOverrideINTEL_VkResult_return) == VK_ERROR_DEVICE_LOST)
4052 this->on_DeviceLost();
4053 this->on_CheckOutOfMemory(vkCmdSetPerformanceOverrideINTEL_VkResult_return, opcode,
4054 context);
4055 android::base::endTrace();
4056 break;
4057 }
4058 #endif
4059 #ifdef VK_EXT_pci_bus_info
4060 #endif
4061 #ifdef VK_AMD_display_native_hdr
4062 #endif
4063 #ifdef VK_FUCHSIA_imagepipe_surface
4064 #endif
4065 #ifdef VK_EXT_metal_surface
4066 #endif
4067 #ifdef VK_EXT_fragment_density_map
4068 #endif
4069 #ifdef VK_EXT_scalar_block_layout
4070 #endif
4071 #ifdef VK_GOOGLE_hlsl_functionality1
4072 #endif
4073 #ifdef VK_GOOGLE_decorate_string
4074 #endif
4075 #ifdef VK_EXT_subgroup_size_control
4076 #endif
4077 #ifdef VK_AMD_shader_core_properties2
4078 #endif
4079 #ifdef VK_AMD_device_coherent_memory
4080 #endif
4081 #ifdef VK_EXT_shader_image_atomic_int64
4082 #endif
4083 #ifdef VK_EXT_memory_budget
4084 #endif
4085 #ifdef VK_EXT_memory_priority
4086 #endif
4087 #ifdef VK_NV_dedicated_allocation_image_aliasing
4088 #endif
4089 #ifdef VK_EXT_buffer_device_address
4090 #endif
4091 #ifdef VK_EXT_tooling_info
4092 #endif
4093 #ifdef VK_EXT_separate_stencil_usage
4094 #endif
4095 #ifdef VK_EXT_validation_features
4096 #endif
4097 #ifdef VK_NV_cooperative_matrix
4098 #endif
4099 #ifdef VK_NV_coverage_reduction_mode
4100 #endif
4101 #ifdef VK_EXT_fragment_shader_interlock
4102 #endif
4103 #ifdef VK_EXT_ycbcr_image_arrays
4104 #endif
4105 #ifdef VK_EXT_provoking_vertex
4106 #endif
4107 #ifdef VK_EXT_full_screen_exclusive
4108 #endif
4109 #ifdef VK_EXT_headless_surface
4110 #endif
4111 #ifdef VK_EXT_line_rasterization
4112 case OP_vkCmdSetLineStippleEXT: {
4113 android::base::beginTrace("vkCmdSetLineStippleEXT subdecode");
4114 uint32_t lineStippleFactor;
4115 uint16_t lineStipplePattern;
4116 memcpy((uint32_t*)&lineStippleFactor, *readStreamPtrPtr, sizeof(uint32_t));
4117 *readStreamPtrPtr += sizeof(uint32_t);
4118 memcpy((uint16_t*)&lineStipplePattern, *readStreamPtrPtr, sizeof(uint16_t));
4119 *readStreamPtrPtr += sizeof(uint16_t);
4120 vk->vkCmdSetLineStippleEXT((VkCommandBuffer)dispatchHandle, lineStippleFactor,
4121 lineStipplePattern);
4122 android::base::endTrace();
4123 break;
4124 }
4125 #endif
4126 #ifdef VK_EXT_shader_atomic_float
4127 #endif
4128 #ifdef VK_EXT_host_query_reset
4129 #endif
4130 #ifdef VK_EXT_index_type_uint8
4131 #endif
4132 #ifdef VK_EXT_extended_dynamic_state
4133 case OP_vkCmdSetCullModeEXT: {
4134 android::base::beginTrace("vkCmdSetCullModeEXT subdecode");
4135 VkCullModeFlags cullMode;
4136 memcpy((VkCullModeFlags*)&cullMode, *readStreamPtrPtr, sizeof(VkCullModeFlags));
4137 *readStreamPtrPtr += sizeof(VkCullModeFlags);
4138 vk->vkCmdSetCullModeEXT((VkCommandBuffer)dispatchHandle, cullMode);
4139 android::base::endTrace();
4140 break;
4141 }
4142 case OP_vkCmdSetFrontFaceEXT: {
4143 android::base::beginTrace("vkCmdSetFrontFaceEXT subdecode");
4144 VkFrontFace frontFace;
4145 memcpy((VkFrontFace*)&frontFace, *readStreamPtrPtr, sizeof(VkFrontFace));
4146 *readStreamPtrPtr += sizeof(VkFrontFace);
4147 vk->vkCmdSetFrontFaceEXT((VkCommandBuffer)dispatchHandle, frontFace);
4148 android::base::endTrace();
4149 break;
4150 }
4151 case OP_vkCmdSetPrimitiveTopologyEXT: {
4152 android::base::beginTrace("vkCmdSetPrimitiveTopologyEXT subdecode");
4153 VkPrimitiveTopology primitiveTopology;
4154 memcpy((VkPrimitiveTopology*)&primitiveTopology, *readStreamPtrPtr,
4155 sizeof(VkPrimitiveTopology));
4156 *readStreamPtrPtr += sizeof(VkPrimitiveTopology);
4157 vk->vkCmdSetPrimitiveTopologyEXT((VkCommandBuffer)dispatchHandle,
4158 primitiveTopology);
4159 android::base::endTrace();
4160 break;
4161 }
4162 case OP_vkCmdSetViewportWithCountEXT: {
4163 android::base::beginTrace("vkCmdSetViewportWithCountEXT subdecode");
4164 uint32_t viewportCount;
4165 const VkViewport* pViewports;
4166 VkViewport stack_pViewports[MAX_STACK_ITEMS];
4167 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
4168 *readStreamPtrPtr += sizeof(uint32_t);
4169 if (((viewportCount)) <= MAX_STACK_ITEMS) {
4170 pViewports = (VkViewport*)stack_pViewports;
4171 } else {
4172 readStream->alloc((void**)&pViewports,
4173 ((viewportCount)) * sizeof(const VkViewport));
4174 }
4175 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
4176 reservedunmarshal_VkViewport(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4177 (VkViewport*)(pViewports + i), readStreamPtrPtr);
4178 }
4179 if (pViewports) {
4180 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
4181 transform_tohost_VkViewport(globalstate, (VkViewport*)(pViewports + i));
4182 }
4183 }
4184 vk->vkCmdSetViewportWithCountEXT((VkCommandBuffer)dispatchHandle, viewportCount,
4185 pViewports);
4186 android::base::endTrace();
4187 break;
4188 }
4189 case OP_vkCmdSetScissorWithCountEXT: {
4190 android::base::beginTrace("vkCmdSetScissorWithCountEXT subdecode");
4191 uint32_t scissorCount;
4192 const VkRect2D* pScissors;
4193 VkRect2D stack_pScissors[MAX_STACK_ITEMS];
4194 memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
4195 *readStreamPtrPtr += sizeof(uint32_t);
4196 if (((scissorCount)) <= MAX_STACK_ITEMS) {
4197 pScissors = (VkRect2D*)stack_pScissors;
4198 } else {
4199 readStream->alloc((void**)&pScissors,
4200 ((scissorCount)) * sizeof(const VkRect2D));
4201 }
4202 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
4203 reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4204 (VkRect2D*)(pScissors + i), readStreamPtrPtr);
4205 }
4206 if (pScissors) {
4207 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
4208 transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pScissors + i));
4209 }
4210 }
4211 vk->vkCmdSetScissorWithCountEXT((VkCommandBuffer)dispatchHandle, scissorCount,
4212 pScissors);
4213 android::base::endTrace();
4214 break;
4215 }
4216 case OP_vkCmdBindVertexBuffers2EXT: {
4217 android::base::beginTrace("vkCmdBindVertexBuffers2EXT subdecode");
4218 uint32_t firstBinding;
4219 uint32_t bindingCount;
4220 const VkBuffer* pBuffers;
4221 VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
4222 const VkDeviceSize* pOffsets;
4223 VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
4224 const VkDeviceSize* pSizes;
4225 VkDeviceSize stack_pSizes[MAX_STACK_ITEMS];
4226 const VkDeviceSize* pStrides;
4227 VkDeviceSize stack_pStrides[MAX_STACK_ITEMS];
4228 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
4229 *readStreamPtrPtr += sizeof(uint32_t);
4230 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
4231 *readStreamPtrPtr += sizeof(uint32_t);
4232 // WARNING PTR CHECK
4233 memcpy((VkBuffer**)&pBuffers, (*readStreamPtrPtr), 8);
4234 android::base::Stream::fromBe64((uint8_t*)&pBuffers);
4235 *readStreamPtrPtr += 8;
4236 if (pBuffers) {
4237 if (((bindingCount)) <= MAX_STACK_ITEMS) {
4238 pBuffers = (VkBuffer*)stack_pBuffers;
4239 } else {
4240 readStream->alloc((void**)&pBuffers,
4241 ((bindingCount)) * sizeof(const VkBuffer));
4242 }
4243 if (((bindingCount))) {
4244 uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*readStreamPtrPtr);
4245 *readStreamPtrPtr += 8 * ((bindingCount));
4246 for (uint32_t k = 0; k < ((bindingCount)); ++k) {
4247 uint64_t tmpval;
4248 memcpy(&tmpval, cgen_var_0_0_ptr + k * 8, sizeof(uint64_t));
4249 *(((VkBuffer*)pBuffers) + k) =
4250 (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval);
4251 }
4252 }
4253 }
4254 if (((bindingCount)) <= MAX_STACK_ITEMS) {
4255 pOffsets = (VkDeviceSize*)stack_pOffsets;
4256 } else {
4257 readStream->alloc((void**)&pOffsets,
4258 ((bindingCount)) * sizeof(const VkDeviceSize));
4259 }
4260 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
4261 ((bindingCount)) * sizeof(const VkDeviceSize));
4262 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
4263 // WARNING PTR CHECK
4264 memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
4265 android::base::Stream::fromBe64((uint8_t*)&pSizes);
4266 *readStreamPtrPtr += 8;
4267 if (pSizes) {
4268 if (((bindingCount)) <= MAX_STACK_ITEMS) {
4269 pSizes = (VkDeviceSize*)stack_pSizes;
4270 } else {
4271 readStream->alloc((void**)&pSizes,
4272 ((bindingCount)) * sizeof(const VkDeviceSize));
4273 }
4274 memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr,
4275 ((bindingCount)) * sizeof(const VkDeviceSize));
4276 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
4277 }
4278 // WARNING PTR CHECK
4279 memcpy((VkDeviceSize**)&pStrides, (*readStreamPtrPtr), 8);
4280 android::base::Stream::fromBe64((uint8_t*)&pStrides);
4281 *readStreamPtrPtr += 8;
4282 if (pStrides) {
4283 if (((bindingCount)) <= MAX_STACK_ITEMS) {
4284 pStrides = (VkDeviceSize*)stack_pStrides;
4285 } else {
4286 readStream->alloc((void**)&pStrides,
4287 ((bindingCount)) * sizeof(const VkDeviceSize));
4288 }
4289 memcpy((VkDeviceSize*)pStrides, *readStreamPtrPtr,
4290 ((bindingCount)) * sizeof(const VkDeviceSize));
4291 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
4292 }
4293 vk->vkCmdBindVertexBuffers2EXT((VkCommandBuffer)dispatchHandle, firstBinding,
4294 bindingCount, pBuffers, pOffsets, pSizes, pStrides);
4295 android::base::endTrace();
4296 break;
4297 }
4298 case OP_vkCmdSetDepthTestEnableEXT: {
4299 android::base::beginTrace("vkCmdSetDepthTestEnableEXT subdecode");
4300 VkBool32 depthTestEnable;
4301 memcpy((VkBool32*)&depthTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
4302 *readStreamPtrPtr += sizeof(VkBool32);
4303 vk->vkCmdSetDepthTestEnableEXT((VkCommandBuffer)dispatchHandle, depthTestEnable);
4304 android::base::endTrace();
4305 break;
4306 }
4307 case OP_vkCmdSetDepthWriteEnableEXT: {
4308 android::base::beginTrace("vkCmdSetDepthWriteEnableEXT subdecode");
4309 VkBool32 depthWriteEnable;
4310 memcpy((VkBool32*)&depthWriteEnable, *readStreamPtrPtr, sizeof(VkBool32));
4311 *readStreamPtrPtr += sizeof(VkBool32);
4312 vk->vkCmdSetDepthWriteEnableEXT((VkCommandBuffer)dispatchHandle, depthWriteEnable);
4313 android::base::endTrace();
4314 break;
4315 }
4316 case OP_vkCmdSetDepthCompareOpEXT: {
4317 android::base::beginTrace("vkCmdSetDepthCompareOpEXT subdecode");
4318 VkCompareOp depthCompareOp;
4319 memcpy((VkCompareOp*)&depthCompareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
4320 *readStreamPtrPtr += sizeof(VkCompareOp);
4321 vk->vkCmdSetDepthCompareOpEXT((VkCommandBuffer)dispatchHandle, depthCompareOp);
4322 android::base::endTrace();
4323 break;
4324 }
4325 case OP_vkCmdSetDepthBoundsTestEnableEXT: {
4326 android::base::beginTrace("vkCmdSetDepthBoundsTestEnableEXT subdecode");
4327 VkBool32 depthBoundsTestEnable;
4328 memcpy((VkBool32*)&depthBoundsTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
4329 *readStreamPtrPtr += sizeof(VkBool32);
4330 vk->vkCmdSetDepthBoundsTestEnableEXT((VkCommandBuffer)dispatchHandle,
4331 depthBoundsTestEnable);
4332 android::base::endTrace();
4333 break;
4334 }
4335 case OP_vkCmdSetStencilTestEnableEXT: {
4336 android::base::beginTrace("vkCmdSetStencilTestEnableEXT subdecode");
4337 VkBool32 stencilTestEnable;
4338 memcpy((VkBool32*)&stencilTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
4339 *readStreamPtrPtr += sizeof(VkBool32);
4340 vk->vkCmdSetStencilTestEnableEXT((VkCommandBuffer)dispatchHandle,
4341 stencilTestEnable);
4342 android::base::endTrace();
4343 break;
4344 }
4345 case OP_vkCmdSetStencilOpEXT: {
4346 android::base::beginTrace("vkCmdSetStencilOpEXT subdecode");
4347 VkStencilFaceFlags faceMask;
4348 VkStencilOp failOp;
4349 VkStencilOp passOp;
4350 VkStencilOp depthFailOp;
4351 VkCompareOp compareOp;
4352 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
4353 sizeof(VkStencilFaceFlags));
4354 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
4355 memcpy((VkStencilOp*)&failOp, *readStreamPtrPtr, sizeof(VkStencilOp));
4356 *readStreamPtrPtr += sizeof(VkStencilOp);
4357 memcpy((VkStencilOp*)&passOp, *readStreamPtrPtr, sizeof(VkStencilOp));
4358 *readStreamPtrPtr += sizeof(VkStencilOp);
4359 memcpy((VkStencilOp*)&depthFailOp, *readStreamPtrPtr, sizeof(VkStencilOp));
4360 *readStreamPtrPtr += sizeof(VkStencilOp);
4361 memcpy((VkCompareOp*)&compareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
4362 *readStreamPtrPtr += sizeof(VkCompareOp);
4363 vk->vkCmdSetStencilOpEXT((VkCommandBuffer)dispatchHandle, faceMask, failOp, passOp,
4364 depthFailOp, compareOp);
4365 android::base::endTrace();
4366 break;
4367 }
4368 #endif
4369 #ifdef VK_EXT_shader_atomic_float2
4370 #endif
4371 #ifdef VK_EXT_surface_maintenance1
4372 #endif
4373 #ifdef VK_EXT_swapchain_maintenance1
4374 #endif
4375 #ifdef VK_EXT_shader_demote_to_helper_invocation
4376 #endif
4377 #ifdef VK_NV_device_generated_commands
4378 case OP_vkCmdPreprocessGeneratedCommandsNV: {
4379 android::base::beginTrace("vkCmdPreprocessGeneratedCommandsNV subdecode");
4380 const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo;
4381 VkGeneratedCommandsInfoNV stack_pGeneratedCommandsInfo[1];
4382 pGeneratedCommandsInfo = (VkGeneratedCommandsInfoNV*)stack_pGeneratedCommandsInfo;
4383 reservedunmarshal_VkGeneratedCommandsInfoNV(
4384 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4385 (VkGeneratedCommandsInfoNV*)(pGeneratedCommandsInfo), readStreamPtrPtr);
4386 if (pGeneratedCommandsInfo) {
4387 transform_tohost_VkGeneratedCommandsInfoNV(
4388 globalstate, (VkGeneratedCommandsInfoNV*)(pGeneratedCommandsInfo));
4389 }
4390 vk->vkCmdPreprocessGeneratedCommandsNV((VkCommandBuffer)dispatchHandle,
4391 pGeneratedCommandsInfo);
4392 android::base::endTrace();
4393 break;
4394 }
4395 case OP_vkCmdExecuteGeneratedCommandsNV: {
4396 android::base::beginTrace("vkCmdExecuteGeneratedCommandsNV subdecode");
4397 VkBool32 isPreprocessed;
4398 const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo;
4399 VkGeneratedCommandsInfoNV stack_pGeneratedCommandsInfo[1];
4400 memcpy((VkBool32*)&isPreprocessed, *readStreamPtrPtr, sizeof(VkBool32));
4401 *readStreamPtrPtr += sizeof(VkBool32);
4402 pGeneratedCommandsInfo = (VkGeneratedCommandsInfoNV*)stack_pGeneratedCommandsInfo;
4403 reservedunmarshal_VkGeneratedCommandsInfoNV(
4404 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4405 (VkGeneratedCommandsInfoNV*)(pGeneratedCommandsInfo), readStreamPtrPtr);
4406 if (pGeneratedCommandsInfo) {
4407 transform_tohost_VkGeneratedCommandsInfoNV(
4408 globalstate, (VkGeneratedCommandsInfoNV*)(pGeneratedCommandsInfo));
4409 }
4410 vk->vkCmdExecuteGeneratedCommandsNV((VkCommandBuffer)dispatchHandle, isPreprocessed,
4411 pGeneratedCommandsInfo);
4412 android::base::endTrace();
4413 break;
4414 }
4415 case OP_vkCmdBindPipelineShaderGroupNV: {
4416 android::base::beginTrace("vkCmdBindPipelineShaderGroupNV subdecode");
4417 VkPipelineBindPoint pipelineBindPoint;
4418 VkPipeline pipeline;
4419 uint32_t groupIndex;
4420 memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
4421 sizeof(VkPipelineBindPoint));
4422 *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
4423 uint64_t cgen_var_0;
4424 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
4425 *readStreamPtrPtr += 1 * 8;
4426 *(VkPipeline*)&pipeline = (VkPipeline)unbox_VkPipeline((VkPipeline)(*&cgen_var_0));
4427 memcpy((uint32_t*)&groupIndex, *readStreamPtrPtr, sizeof(uint32_t));
4428 *readStreamPtrPtr += sizeof(uint32_t);
4429 vk->vkCmdBindPipelineShaderGroupNV((VkCommandBuffer)dispatchHandle,
4430 pipelineBindPoint, pipeline, groupIndex);
4431 android::base::endTrace();
4432 break;
4433 }
4434 #endif
4435 #ifdef VK_NV_inherited_viewport_scissor
4436 #endif
4437 #ifdef VK_EXT_texel_buffer_alignment
4438 #endif
4439 #ifdef VK_QCOM_render_pass_transform
4440 #endif
4441 #ifdef VK_EXT_device_memory_report
4442 #endif
4443 #ifdef VK_EXT_acquire_drm_display
4444 #endif
4445 #ifdef VK_EXT_robustness2
4446 #endif
4447 #ifdef VK_EXT_custom_border_color
4448 #endif
4449 #ifdef VK_GOOGLE_user_type
4450 #endif
4451 #ifdef VK_NV_present_barrier
4452 #endif
4453 #ifdef VK_EXT_private_data
4454 #endif
4455 #ifdef VK_EXT_pipeline_creation_cache_control
4456 #endif
4457 #ifdef VK_NV_device_diagnostics_config
4458 #endif
4459 #ifdef VK_QCOM_render_pass_store_ops
4460 #endif
4461 #ifdef VK_NV_low_latency
4462 #endif
4463 #ifdef VK_EXT_metal_objects
4464 #endif
4465 #ifdef VK_EXT_descriptor_buffer
4466 case OP_vkCmdBindDescriptorBuffersEXT: {
4467 android::base::beginTrace("vkCmdBindDescriptorBuffersEXT subdecode");
4468 uint32_t bufferCount;
4469 const VkDescriptorBufferBindingInfoEXT* pBindingInfos;
4470 VkDescriptorBufferBindingInfoEXT stack_pBindingInfos[MAX_STACK_ITEMS];
4471 memcpy((uint32_t*)&bufferCount, *readStreamPtrPtr, sizeof(uint32_t));
4472 *readStreamPtrPtr += sizeof(uint32_t);
4473 if (((bufferCount)) <= MAX_STACK_ITEMS) {
4474 pBindingInfos = (VkDescriptorBufferBindingInfoEXT*)stack_pBindingInfos;
4475 } else {
4476 readStream->alloc(
4477 (void**)&pBindingInfos,
4478 ((bufferCount)) * sizeof(const VkDescriptorBufferBindingInfoEXT));
4479 }
4480 for (uint32_t i = 0; i < (uint32_t)((bufferCount)); ++i) {
4481 reservedunmarshal_VkDescriptorBufferBindingInfoEXT(
4482 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4483 (VkDescriptorBufferBindingInfoEXT*)(pBindingInfos + i), readStreamPtrPtr);
4484 }
4485 if (pBindingInfos) {
4486 for (uint32_t i = 0; i < (uint32_t)((bufferCount)); ++i) {
4487 transform_tohost_VkDescriptorBufferBindingInfoEXT(
4488 globalstate, (VkDescriptorBufferBindingInfoEXT*)(pBindingInfos + i));
4489 }
4490 }
4491 vk->vkCmdBindDescriptorBuffersEXT((VkCommandBuffer)dispatchHandle, bufferCount,
4492 pBindingInfos);
4493 android::base::endTrace();
4494 break;
4495 }
4496 case OP_vkCmdSetDescriptorBufferOffsetsEXT: {
4497 android::base::beginTrace("vkCmdSetDescriptorBufferOffsetsEXT subdecode");
4498 VkPipelineBindPoint pipelineBindPoint;
4499 VkPipelineLayout layout;
4500 uint32_t firstSet;
4501 uint32_t setCount;
4502 const uint32_t* pBufferIndices;
4503 uint32_t stack_pBufferIndices[MAX_STACK_ITEMS];
4504 const VkDeviceSize* pOffsets;
4505 VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
4506 memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
4507 sizeof(VkPipelineBindPoint));
4508 *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
4509 uint64_t cgen_var_0;
4510 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
4511 *readStreamPtrPtr += 1 * 8;
4512 *(VkPipelineLayout*)&layout =
4513 (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
4514 memcpy((uint32_t*)&firstSet, *readStreamPtrPtr, sizeof(uint32_t));
4515 *readStreamPtrPtr += sizeof(uint32_t);
4516 memcpy((uint32_t*)&setCount, *readStreamPtrPtr, sizeof(uint32_t));
4517 *readStreamPtrPtr += sizeof(uint32_t);
4518 if (((setCount)) <= MAX_STACK_ITEMS) {
4519 pBufferIndices = (uint32_t*)stack_pBufferIndices;
4520 } else {
4521 readStream->alloc((void**)&pBufferIndices,
4522 ((setCount)) * sizeof(const uint32_t));
4523 }
4524 memcpy((uint32_t*)pBufferIndices, *readStreamPtrPtr,
4525 ((setCount)) * sizeof(const uint32_t));
4526 *readStreamPtrPtr += ((setCount)) * sizeof(const uint32_t);
4527 if (((setCount)) <= MAX_STACK_ITEMS) {
4528 pOffsets = (VkDeviceSize*)stack_pOffsets;
4529 } else {
4530 readStream->alloc((void**)&pOffsets, ((setCount)) * sizeof(const VkDeviceSize));
4531 }
4532 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
4533 ((setCount)) * sizeof(const VkDeviceSize));
4534 *readStreamPtrPtr += ((setCount)) * sizeof(const VkDeviceSize);
4535 vk->vkCmdSetDescriptorBufferOffsetsEXT((VkCommandBuffer)dispatchHandle,
4536 pipelineBindPoint, layout, firstSet,
4537 setCount, pBufferIndices, pOffsets);
4538 android::base::endTrace();
4539 break;
4540 }
4541 case OP_vkCmdBindDescriptorBufferEmbeddedSamplersEXT: {
4542 android::base::beginTrace("vkCmdBindDescriptorBufferEmbeddedSamplersEXT subdecode");
4543 VkPipelineBindPoint pipelineBindPoint;
4544 VkPipelineLayout layout;
4545 uint32_t set;
4546 memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
4547 sizeof(VkPipelineBindPoint));
4548 *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
4549 uint64_t cgen_var_0;
4550 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
4551 *readStreamPtrPtr += 1 * 8;
4552 *(VkPipelineLayout*)&layout =
4553 (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
4554 memcpy((uint32_t*)&set, *readStreamPtrPtr, sizeof(uint32_t));
4555 *readStreamPtrPtr += sizeof(uint32_t);
4556 vk->vkCmdBindDescriptorBufferEmbeddedSamplersEXT((VkCommandBuffer)dispatchHandle,
4557 pipelineBindPoint, layout, set);
4558 android::base::endTrace();
4559 break;
4560 }
4561 #endif
4562 #ifdef VK_EXT_graphics_pipeline_library
4563 #endif
4564 #ifdef VK_AMD_shader_early_and_late_fragment_tests
4565 #endif
4566 #ifdef VK_NV_fragment_shading_rate_enums
4567 case OP_vkCmdSetFragmentShadingRateEnumNV: {
4568 android::base::beginTrace("vkCmdSetFragmentShadingRateEnumNV subdecode");
4569 VkFragmentShadingRateNV shadingRate;
4570 VkFragmentShadingRateCombinerOpKHR combinerOps[2];
4571 memcpy((VkFragmentShadingRateNV*)&shadingRate, *readStreamPtrPtr,
4572 sizeof(VkFragmentShadingRateNV));
4573 *readStreamPtrPtr += sizeof(VkFragmentShadingRateNV);
4574 memcpy((VkFragmentShadingRateCombinerOpKHR*)combinerOps, *readStreamPtrPtr,
4575 2 * sizeof(const VkFragmentShadingRateCombinerOpKHR));
4576 *readStreamPtrPtr += 2 * sizeof(const VkFragmentShadingRateCombinerOpKHR);
4577 vk->vkCmdSetFragmentShadingRateEnumNV((VkCommandBuffer)dispatchHandle, shadingRate,
4578 combinerOps);
4579 android::base::endTrace();
4580 break;
4581 }
4582 #endif
4583 #ifdef VK_NV_ray_tracing_motion_blur
4584 #endif
4585 #ifdef VK_EXT_ycbcr_2plane_444_formats
4586 #endif
4587 #ifdef VK_EXT_fragment_density_map2
4588 #endif
4589 #ifdef VK_QCOM_rotated_copy_commands
4590 #endif
4591 #ifdef VK_EXT_image_robustness
4592 #endif
4593 #ifdef VK_EXT_image_compression_control
4594 #endif
4595 #ifdef VK_EXT_attachment_feedback_loop_layout
4596 #endif
4597 #ifdef VK_EXT_4444_formats
4598 #endif
4599 #ifdef VK_EXT_device_fault
4600 #endif
4601 #ifdef VK_ARM_rasterization_order_attachment_access
4602 #endif
4603 #ifdef VK_EXT_rgba10x6_formats
4604 #endif
4605 #ifdef VK_NV_acquire_winrt_display
4606 #endif
4607 #ifdef VK_EXT_directfb_surface
4608 #endif
4609 #ifdef VK_VALVE_mutable_descriptor_type
4610 #endif
4611 #ifdef VK_EXT_vertex_input_dynamic_state
4612 case OP_vkCmdSetVertexInputEXT: {
4613 android::base::beginTrace("vkCmdSetVertexInputEXT subdecode");
4614 uint32_t vertexBindingDescriptionCount;
4615 const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions;
4616 VkVertexInputBindingDescription2EXT
4617 stack_pVertexBindingDescriptions[MAX_STACK_ITEMS];
4618 uint32_t vertexAttributeDescriptionCount;
4619 const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions;
4620 VkVertexInputAttributeDescription2EXT
4621 stack_pVertexAttributeDescriptions[MAX_STACK_ITEMS];
4622 memcpy((uint32_t*)&vertexBindingDescriptionCount, *readStreamPtrPtr,
4623 sizeof(uint32_t));
4624 *readStreamPtrPtr += sizeof(uint32_t);
4625 if (((vertexBindingDescriptionCount)) <= MAX_STACK_ITEMS) {
4626 pVertexBindingDescriptions =
4627 (VkVertexInputBindingDescription2EXT*)stack_pVertexBindingDescriptions;
4628 } else {
4629 readStream->alloc((void**)&pVertexBindingDescriptions,
4630 ((vertexBindingDescriptionCount)) *
4631 sizeof(const VkVertexInputBindingDescription2EXT));
4632 }
4633 for (uint32_t i = 0; i < (uint32_t)((vertexBindingDescriptionCount)); ++i) {
4634 reservedunmarshal_VkVertexInputBindingDescription2EXT(
4635 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4636 (VkVertexInputBindingDescription2EXT*)(pVertexBindingDescriptions + i),
4637 readStreamPtrPtr);
4638 }
4639 memcpy((uint32_t*)&vertexAttributeDescriptionCount, *readStreamPtrPtr,
4640 sizeof(uint32_t));
4641 *readStreamPtrPtr += sizeof(uint32_t);
4642 if (((vertexAttributeDescriptionCount)) <= MAX_STACK_ITEMS) {
4643 pVertexAttributeDescriptions =
4644 (VkVertexInputAttributeDescription2EXT*)stack_pVertexAttributeDescriptions;
4645 } else {
4646 readStream->alloc((void**)&pVertexAttributeDescriptions,
4647 ((vertexAttributeDescriptionCount)) *
4648 sizeof(const VkVertexInputAttributeDescription2EXT));
4649 }
4650 for (uint32_t i = 0; i < (uint32_t)((vertexAttributeDescriptionCount)); ++i) {
4651 reservedunmarshal_VkVertexInputAttributeDescription2EXT(
4652 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4653 (VkVertexInputAttributeDescription2EXT*)(pVertexAttributeDescriptions + i),
4654 readStreamPtrPtr);
4655 }
4656 if (pVertexBindingDescriptions) {
4657 for (uint32_t i = 0; i < (uint32_t)((vertexBindingDescriptionCount)); ++i) {
4658 transform_tohost_VkVertexInputBindingDescription2EXT(
4659 globalstate,
4660 (VkVertexInputBindingDescription2EXT*)(pVertexBindingDescriptions + i));
4661 }
4662 }
4663 if (pVertexAttributeDescriptions) {
4664 for (uint32_t i = 0; i < (uint32_t)((vertexAttributeDescriptionCount)); ++i) {
4665 transform_tohost_VkVertexInputAttributeDescription2EXT(
4666 globalstate,
4667 (VkVertexInputAttributeDescription2EXT*)(pVertexAttributeDescriptions +
4668 i));
4669 }
4670 }
4671 vk->vkCmdSetVertexInputEXT(
4672 (VkCommandBuffer)dispatchHandle, vertexBindingDescriptionCount,
4673 pVertexBindingDescriptions, vertexAttributeDescriptionCount,
4674 pVertexAttributeDescriptions);
4675 android::base::endTrace();
4676 break;
4677 }
4678 #endif
4679 #ifdef VK_EXT_physical_device_drm
4680 #endif
4681 #ifdef VK_EXT_device_address_binding_report
4682 #endif
4683 #ifdef VK_EXT_depth_clip_control
4684 #endif
4685 #ifdef VK_EXT_primitive_topology_list_restart
4686 #endif
4687 #ifdef VK_FUCHSIA_external_memory
4688 #endif
4689 #ifdef VK_FUCHSIA_external_semaphore
4690 #endif
4691 #ifdef VK_FUCHSIA_buffer_collection
4692 #endif
4693 #ifdef VK_HUAWEI_subpass_shading
4694 case OP_vkCmdSubpassShadingHUAWEI: {
4695 android::base::beginTrace("vkCmdSubpassShadingHUAWEI subdecode");
4696 vk->vkCmdSubpassShadingHUAWEI((VkCommandBuffer)dispatchHandle);
4697 android::base::endTrace();
4698 break;
4699 }
4700 #endif
4701 #ifdef VK_HUAWEI_invocation_mask
4702 case OP_vkCmdBindInvocationMaskHUAWEI: {
4703 android::base::beginTrace("vkCmdBindInvocationMaskHUAWEI subdecode");
4704 VkImageView imageView;
4705 VkImageLayout imageLayout;
4706 uint64_t cgen_var_0;
4707 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
4708 *readStreamPtrPtr += 1 * 8;
4709 *(VkImageView*)&imageView =
4710 (VkImageView)unbox_VkImageView((VkImageView)(*&cgen_var_0));
4711 memcpy((VkImageLayout*)&imageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
4712 *readStreamPtrPtr += sizeof(VkImageLayout);
4713 vk->vkCmdBindInvocationMaskHUAWEI((VkCommandBuffer)dispatchHandle, imageView,
4714 imageLayout);
4715 android::base::endTrace();
4716 break;
4717 }
4718 #endif
4719 #ifdef VK_NV_external_memory_rdma
4720 #endif
4721 #ifdef VK_EXT_pipeline_properties
4722 #endif
4723 #ifdef VK_EXT_multisampled_render_to_single_sampled
4724 #endif
4725 #ifdef VK_EXT_extended_dynamic_state2
4726 case OP_vkCmdSetPatchControlPointsEXT: {
4727 android::base::beginTrace("vkCmdSetPatchControlPointsEXT subdecode");
4728 uint32_t patchControlPoints;
4729 memcpy((uint32_t*)&patchControlPoints, *readStreamPtrPtr, sizeof(uint32_t));
4730 *readStreamPtrPtr += sizeof(uint32_t);
4731 vk->vkCmdSetPatchControlPointsEXT((VkCommandBuffer)dispatchHandle,
4732 patchControlPoints);
4733 android::base::endTrace();
4734 break;
4735 }
4736 case OP_vkCmdSetRasterizerDiscardEnableEXT: {
4737 android::base::beginTrace("vkCmdSetRasterizerDiscardEnableEXT subdecode");
4738 VkBool32 rasterizerDiscardEnable;
4739 memcpy((VkBool32*)&rasterizerDiscardEnable, *readStreamPtrPtr, sizeof(VkBool32));
4740 *readStreamPtrPtr += sizeof(VkBool32);
4741 vk->vkCmdSetRasterizerDiscardEnableEXT((VkCommandBuffer)dispatchHandle,
4742 rasterizerDiscardEnable);
4743 android::base::endTrace();
4744 break;
4745 }
4746 case OP_vkCmdSetDepthBiasEnableEXT: {
4747 android::base::beginTrace("vkCmdSetDepthBiasEnableEXT subdecode");
4748 VkBool32 depthBiasEnable;
4749 memcpy((VkBool32*)&depthBiasEnable, *readStreamPtrPtr, sizeof(VkBool32));
4750 *readStreamPtrPtr += sizeof(VkBool32);
4751 vk->vkCmdSetDepthBiasEnableEXT((VkCommandBuffer)dispatchHandle, depthBiasEnable);
4752 android::base::endTrace();
4753 break;
4754 }
4755 case OP_vkCmdSetLogicOpEXT: {
4756 android::base::beginTrace("vkCmdSetLogicOpEXT subdecode");
4757 VkLogicOp logicOp;
4758 memcpy((VkLogicOp*)&logicOp, *readStreamPtrPtr, sizeof(VkLogicOp));
4759 *readStreamPtrPtr += sizeof(VkLogicOp);
4760 vk->vkCmdSetLogicOpEXT((VkCommandBuffer)dispatchHandle, logicOp);
4761 android::base::endTrace();
4762 break;
4763 }
4764 case OP_vkCmdSetPrimitiveRestartEnableEXT: {
4765 android::base::beginTrace("vkCmdSetPrimitiveRestartEnableEXT subdecode");
4766 VkBool32 primitiveRestartEnable;
4767 memcpy((VkBool32*)&primitiveRestartEnable, *readStreamPtrPtr, sizeof(VkBool32));
4768 *readStreamPtrPtr += sizeof(VkBool32);
4769 vk->vkCmdSetPrimitiveRestartEnableEXT((VkCommandBuffer)dispatchHandle,
4770 primitiveRestartEnable);
4771 android::base::endTrace();
4772 break;
4773 }
4774 #endif
4775 #ifdef VK_QNX_screen_surface
4776 #endif
4777 #ifdef VK_EXT_color_write_enable
4778 case OP_vkCmdSetColorWriteEnableEXT: {
4779 android::base::beginTrace("vkCmdSetColorWriteEnableEXT subdecode");
4780 uint32_t attachmentCount;
4781 const VkBool32* pColorWriteEnables;
4782 VkBool32 stack_pColorWriteEnables[MAX_STACK_ITEMS];
4783 memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
4784 *readStreamPtrPtr += sizeof(uint32_t);
4785 if (((attachmentCount)) <= MAX_STACK_ITEMS) {
4786 pColorWriteEnables = (VkBool32*)stack_pColorWriteEnables;
4787 } else {
4788 readStream->alloc((void**)&pColorWriteEnables,
4789 ((attachmentCount)) * sizeof(const VkBool32));
4790 }
4791 memcpy((VkBool32*)pColorWriteEnables, *readStreamPtrPtr,
4792 ((attachmentCount)) * sizeof(const VkBool32));
4793 *readStreamPtrPtr += ((attachmentCount)) * sizeof(const VkBool32);
4794 vk->vkCmdSetColorWriteEnableEXT((VkCommandBuffer)dispatchHandle, attachmentCount,
4795 pColorWriteEnables);
4796 android::base::endTrace();
4797 break;
4798 }
4799 #endif
4800 #ifdef VK_EXT_primitives_generated_query
4801 #endif
4802 #ifdef VK_GOOGLE_gfxstream
4803 case OP_vkBeginCommandBufferAsyncGOOGLE: {
4804 android::base::beginTrace("vkBeginCommandBufferAsyncGOOGLE subdecode");
4805 const VkCommandBufferBeginInfo* pBeginInfo;
4806 VkCommandBufferBeginInfo stack_pBeginInfo[1];
4807 pBeginInfo = (VkCommandBufferBeginInfo*)stack_pBeginInfo;
4808 reservedunmarshal_VkCommandBufferBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4809 (VkCommandBufferBeginInfo*)(pBeginInfo),
4810 readStreamPtrPtr);
4811 if (pBeginInfo) {
4812 transform_tohost_VkCommandBufferBeginInfo(
4813 globalstate, (VkCommandBufferBeginInfo*)(pBeginInfo));
4814 }
4815 this->on_vkBeginCommandBufferAsyncGOOGLE(
4816 pool, (VkCommandBuffer)(boxed_dispatchHandle), pBeginInfo, context);
4817 android::base::endTrace();
4818 break;
4819 }
4820 case OP_vkEndCommandBufferAsyncGOOGLE: {
4821 android::base::beginTrace("vkEndCommandBufferAsyncGOOGLE subdecode");
4822 this->on_vkEndCommandBufferAsyncGOOGLE(
4823 pool, (VkCommandBuffer)(boxed_dispatchHandle), context);
4824 android::base::endTrace();
4825 break;
4826 }
4827 case OP_vkResetCommandBufferAsyncGOOGLE: {
4828 android::base::beginTrace("vkResetCommandBufferAsyncGOOGLE subdecode");
4829 VkCommandBufferResetFlags flags;
4830 memcpy((VkCommandBufferResetFlags*)&flags, *readStreamPtrPtr,
4831 sizeof(VkCommandBufferResetFlags));
4832 *readStreamPtrPtr += sizeof(VkCommandBufferResetFlags);
4833 this->on_vkResetCommandBufferAsyncGOOGLE(
4834 pool, (VkCommandBuffer)(boxed_dispatchHandle), flags);
4835 android::base::endTrace();
4836 break;
4837 }
4838 case OP_vkCommandBufferHostSyncGOOGLE: {
4839 android::base::beginTrace("vkCommandBufferHostSyncGOOGLE subdecode");
4840 uint32_t needHostSync;
4841 uint32_t sequenceNumber;
4842 memcpy((uint32_t*)&needHostSync, *readStreamPtrPtr, sizeof(uint32_t));
4843 *readStreamPtrPtr += sizeof(uint32_t);
4844 memcpy((uint32_t*)&sequenceNumber, *readStreamPtrPtr, sizeof(uint32_t));
4845 *readStreamPtrPtr += sizeof(uint32_t);
4846 this->on_vkCommandBufferHostSyncGOOGLE(
4847 pool, (VkCommandBuffer)(boxed_dispatchHandle), needHostSync, sequenceNumber);
4848 android::base::endTrace();
4849 break;
4850 }
4851 #endif
4852 #ifdef VK_EXT_global_priority_query
4853 #endif
4854 #ifdef VK_EXT_image_view_min_lod
4855 #endif
4856 #ifdef VK_EXT_multi_draw
4857 case OP_vkCmdDrawMultiEXT: {
4858 android::base::beginTrace("vkCmdDrawMultiEXT subdecode");
4859 uint32_t drawCount;
4860 const VkMultiDrawInfoEXT* pVertexInfo;
4861 VkMultiDrawInfoEXT stack_pVertexInfo[MAX_STACK_ITEMS];
4862 uint32_t instanceCount;
4863 uint32_t firstInstance;
4864 uint32_t stride;
4865 memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
4866 *readStreamPtrPtr += sizeof(uint32_t);
4867 // WARNING PTR CHECK
4868 memcpy((VkMultiDrawInfoEXT**)&pVertexInfo, (*readStreamPtrPtr), 8);
4869 android::base::Stream::fromBe64((uint8_t*)&pVertexInfo);
4870 *readStreamPtrPtr += 8;
4871 if (pVertexInfo) {
4872 if (((drawCount)) <= MAX_STACK_ITEMS) {
4873 pVertexInfo = (VkMultiDrawInfoEXT*)stack_pVertexInfo;
4874 } else {
4875 readStream->alloc((void**)&pVertexInfo,
4876 ((drawCount)) * sizeof(const VkMultiDrawInfoEXT));
4877 }
4878 for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i) {
4879 reservedunmarshal_VkMultiDrawInfoEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4880 (VkMultiDrawInfoEXT*)(pVertexInfo + i),
4881 readStreamPtrPtr);
4882 }
4883 }
4884 memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
4885 *readStreamPtrPtr += sizeof(uint32_t);
4886 memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
4887 *readStreamPtrPtr += sizeof(uint32_t);
4888 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
4889 *readStreamPtrPtr += sizeof(uint32_t);
4890 if (pVertexInfo) {
4891 for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i) {
4892 transform_tohost_VkMultiDrawInfoEXT(globalstate,
4893 (VkMultiDrawInfoEXT*)(pVertexInfo + i));
4894 }
4895 }
4896 vk->vkCmdDrawMultiEXT((VkCommandBuffer)dispatchHandle, drawCount, pVertexInfo,
4897 instanceCount, firstInstance, stride);
4898 android::base::endTrace();
4899 break;
4900 }
4901 case OP_vkCmdDrawMultiIndexedEXT: {
4902 android::base::beginTrace("vkCmdDrawMultiIndexedEXT subdecode");
4903 uint32_t drawCount;
4904 const VkMultiDrawIndexedInfoEXT* pIndexInfo;
4905 VkMultiDrawIndexedInfoEXT stack_pIndexInfo[MAX_STACK_ITEMS];
4906 uint32_t instanceCount;
4907 uint32_t firstInstance;
4908 uint32_t stride;
4909 const int32_t* pVertexOffset;
4910 int32_t stack_pVertexOffset[1];
4911 memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
4912 *readStreamPtrPtr += sizeof(uint32_t);
4913 // WARNING PTR CHECK
4914 memcpy((VkMultiDrawIndexedInfoEXT**)&pIndexInfo, (*readStreamPtrPtr), 8);
4915 android::base::Stream::fromBe64((uint8_t*)&pIndexInfo);
4916 *readStreamPtrPtr += 8;
4917 if (pIndexInfo) {
4918 if (((drawCount)) <= MAX_STACK_ITEMS) {
4919 pIndexInfo = (VkMultiDrawIndexedInfoEXT*)stack_pIndexInfo;
4920 } else {
4921 readStream->alloc((void**)&pIndexInfo,
4922 ((drawCount)) * sizeof(const VkMultiDrawIndexedInfoEXT));
4923 }
4924 for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i) {
4925 reservedunmarshal_VkMultiDrawIndexedInfoEXT(
4926 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4927 (VkMultiDrawIndexedInfoEXT*)(pIndexInfo + i), readStreamPtrPtr);
4928 }
4929 }
4930 memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
4931 *readStreamPtrPtr += sizeof(uint32_t);
4932 memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
4933 *readStreamPtrPtr += sizeof(uint32_t);
4934 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
4935 *readStreamPtrPtr += sizeof(uint32_t);
4936 // WARNING PTR CHECK
4937 memcpy((int32_t**)&pVertexOffset, (*readStreamPtrPtr), 8);
4938 android::base::Stream::fromBe64((uint8_t*)&pVertexOffset);
4939 *readStreamPtrPtr += 8;
4940 if (pVertexOffset) {
4941 pVertexOffset = (int32_t*)stack_pVertexOffset;
4942 memcpy((int32_t*)pVertexOffset, *readStreamPtrPtr, sizeof(const int32_t));
4943 *readStreamPtrPtr += sizeof(const int32_t);
4944 }
4945 if (pIndexInfo) {
4946 for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i) {
4947 transform_tohost_VkMultiDrawIndexedInfoEXT(
4948 globalstate, (VkMultiDrawIndexedInfoEXT*)(pIndexInfo + i));
4949 }
4950 }
4951 vk->vkCmdDrawMultiIndexedEXT((VkCommandBuffer)dispatchHandle, drawCount, pIndexInfo,
4952 instanceCount, firstInstance, stride, pVertexOffset);
4953 android::base::endTrace();
4954 break;
4955 }
4956 #endif
4957 #ifdef VK_EXT_image_2d_view_of_3d
4958 #endif
4959 #ifdef VK_EXT_shader_tile_image
4960 #endif
4961 #ifdef VK_EXT_opacity_micromap
4962 case OP_vkCmdBuildMicromapsEXT: {
4963 android::base::beginTrace("vkCmdBuildMicromapsEXT subdecode");
4964 uint32_t infoCount;
4965 const VkMicromapBuildInfoEXT* pInfos;
4966 VkMicromapBuildInfoEXT stack_pInfos[MAX_STACK_ITEMS];
4967 memcpy((uint32_t*)&infoCount, *readStreamPtrPtr, sizeof(uint32_t));
4968 *readStreamPtrPtr += sizeof(uint32_t);
4969 if (((infoCount)) <= MAX_STACK_ITEMS) {
4970 pInfos = (VkMicromapBuildInfoEXT*)stack_pInfos;
4971 } else {
4972 readStream->alloc((void**)&pInfos,
4973 ((infoCount)) * sizeof(const VkMicromapBuildInfoEXT));
4974 }
4975 for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
4976 reservedunmarshal_VkMicromapBuildInfoEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4977 (VkMicromapBuildInfoEXT*)(pInfos + i),
4978 readStreamPtrPtr);
4979 }
4980 if (pInfos) {
4981 for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
4982 transform_tohost_VkMicromapBuildInfoEXT(
4983 globalstate, (VkMicromapBuildInfoEXT*)(pInfos + i));
4984 }
4985 }
4986 vk->vkCmdBuildMicromapsEXT((VkCommandBuffer)dispatchHandle, infoCount, pInfos);
4987 android::base::endTrace();
4988 break;
4989 }
4990 case OP_vkCmdCopyMicromapEXT: {
4991 android::base::beginTrace("vkCmdCopyMicromapEXT subdecode");
4992 const VkCopyMicromapInfoEXT* pInfo;
4993 VkCopyMicromapInfoEXT stack_pInfo[1];
4994 pInfo = (VkCopyMicromapInfoEXT*)stack_pInfo;
4995 reservedunmarshal_VkCopyMicromapInfoEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
4996 (VkCopyMicromapInfoEXT*)(pInfo),
4997 readStreamPtrPtr);
4998 if (pInfo) {
4999 transform_tohost_VkCopyMicromapInfoEXT(globalstate,
5000 (VkCopyMicromapInfoEXT*)(pInfo));
5001 }
5002 vk->vkCmdCopyMicromapEXT((VkCommandBuffer)dispatchHandle, pInfo);
5003 android::base::endTrace();
5004 break;
5005 }
5006 case OP_vkCmdCopyMicromapToMemoryEXT: {
5007 android::base::beginTrace("vkCmdCopyMicromapToMemoryEXT subdecode");
5008 const VkCopyMicromapToMemoryInfoEXT* pInfo;
5009 VkCopyMicromapToMemoryInfoEXT stack_pInfo[1];
5010 pInfo = (VkCopyMicromapToMemoryInfoEXT*)stack_pInfo;
5011 reservedunmarshal_VkCopyMicromapToMemoryInfoEXT(
5012 readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyMicromapToMemoryInfoEXT*)(pInfo),
5013 readStreamPtrPtr);
5014 if (pInfo) {
5015 transform_tohost_VkCopyMicromapToMemoryInfoEXT(
5016 globalstate, (VkCopyMicromapToMemoryInfoEXT*)(pInfo));
5017 }
5018 vk->vkCmdCopyMicromapToMemoryEXT((VkCommandBuffer)dispatchHandle, pInfo);
5019 android::base::endTrace();
5020 break;
5021 }
5022 case OP_vkCmdCopyMemoryToMicromapEXT: {
5023 android::base::beginTrace("vkCmdCopyMemoryToMicromapEXT subdecode");
5024 const VkCopyMemoryToMicromapInfoEXT* pInfo;
5025 VkCopyMemoryToMicromapInfoEXT stack_pInfo[1];
5026 pInfo = (VkCopyMemoryToMicromapInfoEXT*)stack_pInfo;
5027 reservedunmarshal_VkCopyMemoryToMicromapInfoEXT(
5028 readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyMemoryToMicromapInfoEXT*)(pInfo),
5029 readStreamPtrPtr);
5030 if (pInfo) {
5031 transform_tohost_VkCopyMemoryToMicromapInfoEXT(
5032 globalstate, (VkCopyMemoryToMicromapInfoEXT*)(pInfo));
5033 }
5034 vk->vkCmdCopyMemoryToMicromapEXT((VkCommandBuffer)dispatchHandle, pInfo);
5035 android::base::endTrace();
5036 break;
5037 }
5038 case OP_vkCmdWriteMicromapsPropertiesEXT: {
5039 android::base::beginTrace("vkCmdWriteMicromapsPropertiesEXT subdecode");
5040 uint32_t micromapCount;
5041 const VkMicromapEXT* pMicromaps;
5042 VkMicromapEXT stack_pMicromaps[MAX_STACK_ITEMS];
5043 VkQueryType queryType;
5044 VkQueryPool queryPool;
5045 uint32_t firstQuery;
5046 memcpy((uint32_t*)µmapCount, *readStreamPtrPtr, sizeof(uint32_t));
5047 *readStreamPtrPtr += sizeof(uint32_t);
5048 if (((micromapCount)) <= MAX_STACK_ITEMS) {
5049 pMicromaps = (VkMicromapEXT*)stack_pMicromaps;
5050 } else {
5051 readStream->alloc((void**)&pMicromaps,
5052 ((micromapCount)) * sizeof(const VkMicromapEXT));
5053 }
5054 for (uint32_t i = 0; i < (uint32_t)((micromapCount)); ++i) {
5055 memcpy((VkMicromapEXT*)&pMicromaps[i], (*readStreamPtrPtr), 8);
5056 android::base::Stream::fromBe64((uint8_t*)&pMicromaps[i]);
5057 *readStreamPtrPtr += 8;
5058 }
5059 memcpy((VkQueryType*)&queryType, *readStreamPtrPtr, sizeof(VkQueryType));
5060 *readStreamPtrPtr += sizeof(VkQueryType);
5061 uint64_t cgen_var_0;
5062 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5063 *readStreamPtrPtr += 1 * 8;
5064 *(VkQueryPool*)&queryPool =
5065 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
5066 memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
5067 *readStreamPtrPtr += sizeof(uint32_t);
5068 vk->vkCmdWriteMicromapsPropertiesEXT((VkCommandBuffer)dispatchHandle, micromapCount,
5069 pMicromaps, queryType, queryPool, firstQuery);
5070 android::base::endTrace();
5071 break;
5072 }
5073 #endif
5074 #ifdef VK_NV_displacement_micromap
5075 #endif
5076 #ifdef VK_EXT_load_store_op_none
5077 #endif
5078 #ifdef VK_HUAWEI_cluster_culling_shader
5079 case OP_vkCmdDrawClusterHUAWEI: {
5080 android::base::beginTrace("vkCmdDrawClusterHUAWEI subdecode");
5081 uint32_t groupCountX;
5082 uint32_t groupCountY;
5083 uint32_t groupCountZ;
5084 memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
5085 *readStreamPtrPtr += sizeof(uint32_t);
5086 memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
5087 *readStreamPtrPtr += sizeof(uint32_t);
5088 memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
5089 *readStreamPtrPtr += sizeof(uint32_t);
5090 vk->vkCmdDrawClusterHUAWEI((VkCommandBuffer)dispatchHandle, groupCountX,
5091 groupCountY, groupCountZ);
5092 android::base::endTrace();
5093 break;
5094 }
5095 case OP_vkCmdDrawClusterIndirectHUAWEI: {
5096 android::base::beginTrace("vkCmdDrawClusterIndirectHUAWEI subdecode");
5097 VkBuffer buffer;
5098 VkDeviceSize offset;
5099 uint64_t cgen_var_0;
5100 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5101 *readStreamPtrPtr += 1 * 8;
5102 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
5103 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
5104 *readStreamPtrPtr += sizeof(VkDeviceSize);
5105 vk->vkCmdDrawClusterIndirectHUAWEI((VkCommandBuffer)dispatchHandle, buffer, offset);
5106 android::base::endTrace();
5107 break;
5108 }
5109 #endif
5110 #ifdef VK_EXT_border_color_swizzle
5111 #endif
5112 #ifdef VK_EXT_pageable_device_local_memory
5113 #endif
5114 #ifdef VK_ARM_shader_core_properties
5115 #endif
5116 #ifdef VK_EXT_image_sliced_view_of_3d
5117 #endif
5118 #ifdef VK_VALVE_descriptor_set_host_mapping
5119 #endif
5120 #ifdef VK_EXT_depth_clamp_zero_one
5121 #endif
5122 #ifdef VK_EXT_non_seamless_cube_map
5123 #endif
5124 #ifdef VK_QCOM_fragment_density_map_offset
5125 #endif
5126 #ifdef VK_NV_copy_memory_indirect
5127 case OP_vkCmdCopyMemoryIndirectNV: {
5128 android::base::beginTrace("vkCmdCopyMemoryIndirectNV subdecode");
5129 VkDeviceAddress copyBufferAddress;
5130 uint32_t copyCount;
5131 uint32_t stride;
5132 memcpy((VkDeviceAddress*)©BufferAddress, *readStreamPtrPtr,
5133 sizeof(VkDeviceAddress));
5134 *readStreamPtrPtr += sizeof(VkDeviceAddress);
5135 memcpy((uint32_t*)©Count, *readStreamPtrPtr, sizeof(uint32_t));
5136 *readStreamPtrPtr += sizeof(uint32_t);
5137 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
5138 *readStreamPtrPtr += sizeof(uint32_t);
5139 vk->vkCmdCopyMemoryIndirectNV((VkCommandBuffer)dispatchHandle, copyBufferAddress,
5140 copyCount, stride);
5141 android::base::endTrace();
5142 break;
5143 }
5144 case OP_vkCmdCopyMemoryToImageIndirectNV: {
5145 android::base::beginTrace("vkCmdCopyMemoryToImageIndirectNV subdecode");
5146 VkDeviceAddress copyBufferAddress;
5147 uint32_t copyCount;
5148 uint32_t stride;
5149 VkImage dstImage;
5150 VkImageLayout dstImageLayout;
5151 const VkImageSubresourceLayers* pImageSubresources;
5152 VkImageSubresourceLayers stack_pImageSubresources[MAX_STACK_ITEMS];
5153 memcpy((VkDeviceAddress*)©BufferAddress, *readStreamPtrPtr,
5154 sizeof(VkDeviceAddress));
5155 *readStreamPtrPtr += sizeof(VkDeviceAddress);
5156 memcpy((uint32_t*)©Count, *readStreamPtrPtr, sizeof(uint32_t));
5157 *readStreamPtrPtr += sizeof(uint32_t);
5158 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
5159 *readStreamPtrPtr += sizeof(uint32_t);
5160 uint64_t cgen_var_0;
5161 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
5162 *readStreamPtrPtr += 1 * 8;
5163 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
5164 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
5165 *readStreamPtrPtr += sizeof(VkImageLayout);
5166 if (((copyCount)) <= MAX_STACK_ITEMS) {
5167 pImageSubresources = (VkImageSubresourceLayers*)stack_pImageSubresources;
5168 } else {
5169 readStream->alloc((void**)&pImageSubresources,
5170 ((copyCount)) * sizeof(const VkImageSubresourceLayers));
5171 }
5172 for (uint32_t i = 0; i < (uint32_t)((copyCount)); ++i) {
5173 reservedunmarshal_VkImageSubresourceLayers(
5174 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5175 (VkImageSubresourceLayers*)(pImageSubresources + i), readStreamPtrPtr);
5176 }
5177 if (pImageSubresources) {
5178 for (uint32_t i = 0; i < (uint32_t)((copyCount)); ++i) {
5179 transform_tohost_VkImageSubresourceLayers(
5180 globalstate, (VkImageSubresourceLayers*)(pImageSubresources + i));
5181 }
5182 }
5183 vk->vkCmdCopyMemoryToImageIndirectNV((VkCommandBuffer)dispatchHandle,
5184 copyBufferAddress, copyCount, stride, dstImage,
5185 dstImageLayout, pImageSubresources);
5186 android::base::endTrace();
5187 break;
5188 }
5189 #endif
5190 #ifdef VK_NV_memory_decompression
5191 case OP_vkCmdDecompressMemoryNV: {
5192 android::base::beginTrace("vkCmdDecompressMemoryNV subdecode");
5193 uint32_t decompressRegionCount;
5194 const VkDecompressMemoryRegionNV* pDecompressMemoryRegions;
5195 VkDecompressMemoryRegionNV stack_pDecompressMemoryRegions[MAX_STACK_ITEMS];
5196 memcpy((uint32_t*)&decompressRegionCount, *readStreamPtrPtr, sizeof(uint32_t));
5197 *readStreamPtrPtr += sizeof(uint32_t);
5198 if (((decompressRegionCount)) <= MAX_STACK_ITEMS) {
5199 pDecompressMemoryRegions =
5200 (VkDecompressMemoryRegionNV*)stack_pDecompressMemoryRegions;
5201 } else {
5202 readStream->alloc(
5203 (void**)&pDecompressMemoryRegions,
5204 ((decompressRegionCount)) * sizeof(const VkDecompressMemoryRegionNV));
5205 }
5206 for (uint32_t i = 0; i < (uint32_t)((decompressRegionCount)); ++i) {
5207 reservedunmarshal_VkDecompressMemoryRegionNV(
5208 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5209 (VkDecompressMemoryRegionNV*)(pDecompressMemoryRegions + i),
5210 readStreamPtrPtr);
5211 }
5212 if (pDecompressMemoryRegions) {
5213 for (uint32_t i = 0; i < (uint32_t)((decompressRegionCount)); ++i) {
5214 transform_tohost_VkDecompressMemoryRegionNV(
5215 globalstate,
5216 (VkDecompressMemoryRegionNV*)(pDecompressMemoryRegions + i));
5217 }
5218 }
5219 vk->vkCmdDecompressMemoryNV((VkCommandBuffer)dispatchHandle, decompressRegionCount,
5220 pDecompressMemoryRegions);
5221 android::base::endTrace();
5222 break;
5223 }
5224 case OP_vkCmdDecompressMemoryIndirectCountNV: {
5225 android::base::beginTrace("vkCmdDecompressMemoryIndirectCountNV subdecode");
5226 VkDeviceAddress indirectCommandsAddress;
5227 VkDeviceAddress indirectCommandsCountAddress;
5228 uint32_t stride;
5229 memcpy((VkDeviceAddress*)&indirectCommandsAddress, *readStreamPtrPtr,
5230 sizeof(VkDeviceAddress));
5231 *readStreamPtrPtr += sizeof(VkDeviceAddress);
5232 memcpy((VkDeviceAddress*)&indirectCommandsCountAddress, *readStreamPtrPtr,
5233 sizeof(VkDeviceAddress));
5234 *readStreamPtrPtr += sizeof(VkDeviceAddress);
5235 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
5236 *readStreamPtrPtr += sizeof(uint32_t);
5237 vk->vkCmdDecompressMemoryIndirectCountNV((VkCommandBuffer)dispatchHandle,
5238 indirectCommandsAddress,
5239 indirectCommandsCountAddress, stride);
5240 android::base::endTrace();
5241 break;
5242 }
5243 #endif
5244 #ifdef VK_NV_linear_color_attachment
5245 #endif
5246 #ifdef VK_GOOGLE_surfaceless_query
5247 #endif
5248 #ifdef VK_EXT_image_compression_control_swapchain
5249 #endif
5250 #ifdef VK_QCOM_image_processing
5251 #endif
5252 #ifdef VK_EXT_extended_dynamic_state3
5253 case OP_vkCmdSetTessellationDomainOriginEXT: {
5254 android::base::beginTrace("vkCmdSetTessellationDomainOriginEXT subdecode");
5255 VkTessellationDomainOrigin domainOrigin;
5256 memcpy((VkTessellationDomainOrigin*)&domainOrigin, *readStreamPtrPtr,
5257 sizeof(VkTessellationDomainOrigin));
5258 *readStreamPtrPtr += sizeof(VkTessellationDomainOrigin);
5259 vk->vkCmdSetTessellationDomainOriginEXT((VkCommandBuffer)dispatchHandle,
5260 domainOrigin);
5261 android::base::endTrace();
5262 break;
5263 }
5264 case OP_vkCmdSetDepthClampEnableEXT: {
5265 android::base::beginTrace("vkCmdSetDepthClampEnableEXT subdecode");
5266 VkBool32 depthClampEnable;
5267 memcpy((VkBool32*)&depthClampEnable, *readStreamPtrPtr, sizeof(VkBool32));
5268 *readStreamPtrPtr += sizeof(VkBool32);
5269 vk->vkCmdSetDepthClampEnableEXT((VkCommandBuffer)dispatchHandle, depthClampEnable);
5270 android::base::endTrace();
5271 break;
5272 }
5273 case OP_vkCmdSetPolygonModeEXT: {
5274 android::base::beginTrace("vkCmdSetPolygonModeEXT subdecode");
5275 VkPolygonMode polygonMode;
5276 memcpy((VkPolygonMode*)&polygonMode, *readStreamPtrPtr, sizeof(VkPolygonMode));
5277 *readStreamPtrPtr += sizeof(VkPolygonMode);
5278 vk->vkCmdSetPolygonModeEXT((VkCommandBuffer)dispatchHandle, polygonMode);
5279 android::base::endTrace();
5280 break;
5281 }
5282 case OP_vkCmdSetRasterizationSamplesEXT: {
5283 android::base::beginTrace("vkCmdSetRasterizationSamplesEXT subdecode");
5284 VkSampleCountFlagBits rasterizationSamples;
5285 memcpy((VkSampleCountFlagBits*)&rasterizationSamples, *readStreamPtrPtr,
5286 sizeof(VkSampleCountFlagBits));
5287 *readStreamPtrPtr += sizeof(VkSampleCountFlagBits);
5288 vk->vkCmdSetRasterizationSamplesEXT((VkCommandBuffer)dispatchHandle,
5289 rasterizationSamples);
5290 android::base::endTrace();
5291 break;
5292 }
5293 case OP_vkCmdSetSampleMaskEXT: {
5294 android::base::beginTrace("vkCmdSetSampleMaskEXT subdecode");
5295 VkSampleCountFlagBits samples;
5296 const VkSampleMask* pSampleMask;
5297 VkSampleMask stack_pSampleMask[MAX_STACK_ITEMS];
5298 memcpy((VkSampleCountFlagBits*)&samples, *readStreamPtrPtr,
5299 sizeof(VkSampleCountFlagBits));
5300 *readStreamPtrPtr += sizeof(VkSampleCountFlagBits);
5301 if (int(samples / 32) <= MAX_STACK_ITEMS) {
5302 pSampleMask = (VkSampleMask*)stack_pSampleMask;
5303 } else {
5304 readStream->alloc((void**)&pSampleMask,
5305 int(samples / 32) * sizeof(const VkSampleMask));
5306 }
5307 memcpy((VkSampleMask*)pSampleMask, *readStreamPtrPtr,
5308 int(samples / 32) * sizeof(const VkSampleMask));
5309 *readStreamPtrPtr += int(samples / 32) * sizeof(const VkSampleMask);
5310 vk->vkCmdSetSampleMaskEXT((VkCommandBuffer)dispatchHandle, samples, pSampleMask);
5311 android::base::endTrace();
5312 break;
5313 }
5314 case OP_vkCmdSetAlphaToCoverageEnableEXT: {
5315 android::base::beginTrace("vkCmdSetAlphaToCoverageEnableEXT subdecode");
5316 VkBool32 alphaToCoverageEnable;
5317 memcpy((VkBool32*)&alphaToCoverageEnable, *readStreamPtrPtr, sizeof(VkBool32));
5318 *readStreamPtrPtr += sizeof(VkBool32);
5319 vk->vkCmdSetAlphaToCoverageEnableEXT((VkCommandBuffer)dispatchHandle,
5320 alphaToCoverageEnable);
5321 android::base::endTrace();
5322 break;
5323 }
5324 case OP_vkCmdSetAlphaToOneEnableEXT: {
5325 android::base::beginTrace("vkCmdSetAlphaToOneEnableEXT subdecode");
5326 VkBool32 alphaToOneEnable;
5327 memcpy((VkBool32*)&alphaToOneEnable, *readStreamPtrPtr, sizeof(VkBool32));
5328 *readStreamPtrPtr += sizeof(VkBool32);
5329 vk->vkCmdSetAlphaToOneEnableEXT((VkCommandBuffer)dispatchHandle, alphaToOneEnable);
5330 android::base::endTrace();
5331 break;
5332 }
5333 case OP_vkCmdSetLogicOpEnableEXT: {
5334 android::base::beginTrace("vkCmdSetLogicOpEnableEXT subdecode");
5335 VkBool32 logicOpEnable;
5336 memcpy((VkBool32*)&logicOpEnable, *readStreamPtrPtr, sizeof(VkBool32));
5337 *readStreamPtrPtr += sizeof(VkBool32);
5338 vk->vkCmdSetLogicOpEnableEXT((VkCommandBuffer)dispatchHandle, logicOpEnable);
5339 android::base::endTrace();
5340 break;
5341 }
5342 case OP_vkCmdSetColorBlendEnableEXT: {
5343 android::base::beginTrace("vkCmdSetColorBlendEnableEXT subdecode");
5344 uint32_t firstAttachment;
5345 uint32_t attachmentCount;
5346 const VkBool32* pColorBlendEnables;
5347 VkBool32 stack_pColorBlendEnables[MAX_STACK_ITEMS];
5348 memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
5349 *readStreamPtrPtr += sizeof(uint32_t);
5350 memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
5351 *readStreamPtrPtr += sizeof(uint32_t);
5352 if (((attachmentCount)) <= MAX_STACK_ITEMS) {
5353 pColorBlendEnables = (VkBool32*)stack_pColorBlendEnables;
5354 } else {
5355 readStream->alloc((void**)&pColorBlendEnables,
5356 ((attachmentCount)) * sizeof(const VkBool32));
5357 }
5358 memcpy((VkBool32*)pColorBlendEnables, *readStreamPtrPtr,
5359 ((attachmentCount)) * sizeof(const VkBool32));
5360 *readStreamPtrPtr += ((attachmentCount)) * sizeof(const VkBool32);
5361 vk->vkCmdSetColorBlendEnableEXT((VkCommandBuffer)dispatchHandle, firstAttachment,
5362 attachmentCount, pColorBlendEnables);
5363 android::base::endTrace();
5364 break;
5365 }
5366 case OP_vkCmdSetColorBlendEquationEXT: {
5367 android::base::beginTrace("vkCmdSetColorBlendEquationEXT subdecode");
5368 uint32_t firstAttachment;
5369 uint32_t attachmentCount;
5370 const VkColorBlendEquationEXT* pColorBlendEquations;
5371 VkColorBlendEquationEXT stack_pColorBlendEquations[MAX_STACK_ITEMS];
5372 memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
5373 *readStreamPtrPtr += sizeof(uint32_t);
5374 memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
5375 *readStreamPtrPtr += sizeof(uint32_t);
5376 if (((attachmentCount)) <= MAX_STACK_ITEMS) {
5377 pColorBlendEquations = (VkColorBlendEquationEXT*)stack_pColorBlendEquations;
5378 } else {
5379 readStream->alloc((void**)&pColorBlendEquations,
5380 ((attachmentCount)) * sizeof(const VkColorBlendEquationEXT));
5381 }
5382 for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
5383 reservedunmarshal_VkColorBlendEquationEXT(
5384 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5385 (VkColorBlendEquationEXT*)(pColorBlendEquations + i), readStreamPtrPtr);
5386 }
5387 if (pColorBlendEquations) {
5388 for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
5389 transform_tohost_VkColorBlendEquationEXT(
5390 globalstate, (VkColorBlendEquationEXT*)(pColorBlendEquations + i));
5391 }
5392 }
5393 vk->vkCmdSetColorBlendEquationEXT((VkCommandBuffer)dispatchHandle, firstAttachment,
5394 attachmentCount, pColorBlendEquations);
5395 android::base::endTrace();
5396 break;
5397 }
5398 case OP_vkCmdSetColorWriteMaskEXT: {
5399 android::base::beginTrace("vkCmdSetColorWriteMaskEXT subdecode");
5400 uint32_t firstAttachment;
5401 uint32_t attachmentCount;
5402 const VkColorComponentFlags* pColorWriteMasks;
5403 VkColorComponentFlags stack_pColorWriteMasks[MAX_STACK_ITEMS];
5404 memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
5405 *readStreamPtrPtr += sizeof(uint32_t);
5406 memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
5407 *readStreamPtrPtr += sizeof(uint32_t);
5408 // WARNING PTR CHECK
5409 memcpy((VkColorComponentFlags**)&pColorWriteMasks, (*readStreamPtrPtr), 8);
5410 android::base::Stream::fromBe64((uint8_t*)&pColorWriteMasks);
5411 *readStreamPtrPtr += 8;
5412 if (pColorWriteMasks) {
5413 if (((attachmentCount)) <= MAX_STACK_ITEMS) {
5414 pColorWriteMasks = (VkColorComponentFlags*)stack_pColorWriteMasks;
5415 } else {
5416 readStream->alloc(
5417 (void**)&pColorWriteMasks,
5418 ((attachmentCount)) * sizeof(const VkColorComponentFlags));
5419 }
5420 memcpy((VkColorComponentFlags*)pColorWriteMasks, *readStreamPtrPtr,
5421 ((attachmentCount)) * sizeof(const VkColorComponentFlags));
5422 *readStreamPtrPtr += ((attachmentCount)) * sizeof(const VkColorComponentFlags);
5423 }
5424 vk->vkCmdSetColorWriteMaskEXT((VkCommandBuffer)dispatchHandle, firstAttachment,
5425 attachmentCount, pColorWriteMasks);
5426 android::base::endTrace();
5427 break;
5428 }
5429 case OP_vkCmdSetRasterizationStreamEXT: {
5430 android::base::beginTrace("vkCmdSetRasterizationStreamEXT subdecode");
5431 uint32_t rasterizationStream;
5432 memcpy((uint32_t*)&rasterizationStream, *readStreamPtrPtr, sizeof(uint32_t));
5433 *readStreamPtrPtr += sizeof(uint32_t);
5434 vk->vkCmdSetRasterizationStreamEXT((VkCommandBuffer)dispatchHandle,
5435 rasterizationStream);
5436 android::base::endTrace();
5437 break;
5438 }
5439 case OP_vkCmdSetConservativeRasterizationModeEXT: {
5440 android::base::beginTrace("vkCmdSetConservativeRasterizationModeEXT subdecode");
5441 VkConservativeRasterizationModeEXT conservativeRasterizationMode;
5442 memcpy((VkConservativeRasterizationModeEXT*)&conservativeRasterizationMode,
5443 *readStreamPtrPtr, sizeof(VkConservativeRasterizationModeEXT));
5444 *readStreamPtrPtr += sizeof(VkConservativeRasterizationModeEXT);
5445 vk->vkCmdSetConservativeRasterizationModeEXT((VkCommandBuffer)dispatchHandle,
5446 conservativeRasterizationMode);
5447 android::base::endTrace();
5448 break;
5449 }
5450 case OP_vkCmdSetExtraPrimitiveOverestimationSizeEXT: {
5451 android::base::beginTrace("vkCmdSetExtraPrimitiveOverestimationSizeEXT subdecode");
5452 float extraPrimitiveOverestimationSize;
5453 memcpy((float*)&extraPrimitiveOverestimationSize, *readStreamPtrPtr, sizeof(float));
5454 *readStreamPtrPtr += sizeof(float);
5455 vk->vkCmdSetExtraPrimitiveOverestimationSizeEXT((VkCommandBuffer)dispatchHandle,
5456 extraPrimitiveOverestimationSize);
5457 android::base::endTrace();
5458 break;
5459 }
5460 case OP_vkCmdSetDepthClipEnableEXT: {
5461 android::base::beginTrace("vkCmdSetDepthClipEnableEXT subdecode");
5462 VkBool32 depthClipEnable;
5463 memcpy((VkBool32*)&depthClipEnable, *readStreamPtrPtr, sizeof(VkBool32));
5464 *readStreamPtrPtr += sizeof(VkBool32);
5465 vk->vkCmdSetDepthClipEnableEXT((VkCommandBuffer)dispatchHandle, depthClipEnable);
5466 android::base::endTrace();
5467 break;
5468 }
5469 case OP_vkCmdSetSampleLocationsEnableEXT: {
5470 android::base::beginTrace("vkCmdSetSampleLocationsEnableEXT subdecode");
5471 VkBool32 sampleLocationsEnable;
5472 memcpy((VkBool32*)&sampleLocationsEnable, *readStreamPtrPtr, sizeof(VkBool32));
5473 *readStreamPtrPtr += sizeof(VkBool32);
5474 vk->vkCmdSetSampleLocationsEnableEXT((VkCommandBuffer)dispatchHandle,
5475 sampleLocationsEnable);
5476 android::base::endTrace();
5477 break;
5478 }
5479 case OP_vkCmdSetColorBlendAdvancedEXT: {
5480 android::base::beginTrace("vkCmdSetColorBlendAdvancedEXT subdecode");
5481 uint32_t firstAttachment;
5482 uint32_t attachmentCount;
5483 const VkColorBlendAdvancedEXT* pColorBlendAdvanced;
5484 VkColorBlendAdvancedEXT stack_pColorBlendAdvanced[MAX_STACK_ITEMS];
5485 memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
5486 *readStreamPtrPtr += sizeof(uint32_t);
5487 memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
5488 *readStreamPtrPtr += sizeof(uint32_t);
5489 if (((attachmentCount)) <= MAX_STACK_ITEMS) {
5490 pColorBlendAdvanced = (VkColorBlendAdvancedEXT*)stack_pColorBlendAdvanced;
5491 } else {
5492 readStream->alloc((void**)&pColorBlendAdvanced,
5493 ((attachmentCount)) * sizeof(const VkColorBlendAdvancedEXT));
5494 }
5495 for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
5496 reservedunmarshal_VkColorBlendAdvancedEXT(
5497 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5498 (VkColorBlendAdvancedEXT*)(pColorBlendAdvanced + i), readStreamPtrPtr);
5499 }
5500 if (pColorBlendAdvanced) {
5501 for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
5502 transform_tohost_VkColorBlendAdvancedEXT(
5503 globalstate, (VkColorBlendAdvancedEXT*)(pColorBlendAdvanced + i));
5504 }
5505 }
5506 vk->vkCmdSetColorBlendAdvancedEXT((VkCommandBuffer)dispatchHandle, firstAttachment,
5507 attachmentCount, pColorBlendAdvanced);
5508 android::base::endTrace();
5509 break;
5510 }
5511 case OP_vkCmdSetProvokingVertexModeEXT: {
5512 android::base::beginTrace("vkCmdSetProvokingVertexModeEXT subdecode");
5513 VkProvokingVertexModeEXT provokingVertexMode;
5514 memcpy((VkProvokingVertexModeEXT*)&provokingVertexMode, *readStreamPtrPtr,
5515 sizeof(VkProvokingVertexModeEXT));
5516 *readStreamPtrPtr += sizeof(VkProvokingVertexModeEXT);
5517 vk->vkCmdSetProvokingVertexModeEXT((VkCommandBuffer)dispatchHandle,
5518 provokingVertexMode);
5519 android::base::endTrace();
5520 break;
5521 }
5522 case OP_vkCmdSetLineRasterizationModeEXT: {
5523 android::base::beginTrace("vkCmdSetLineRasterizationModeEXT subdecode");
5524 VkLineRasterizationModeEXT lineRasterizationMode;
5525 memcpy((VkLineRasterizationModeEXT*)&lineRasterizationMode, *readStreamPtrPtr,
5526 sizeof(VkLineRasterizationModeEXT));
5527 *readStreamPtrPtr += sizeof(VkLineRasterizationModeEXT);
5528 vk->vkCmdSetLineRasterizationModeEXT((VkCommandBuffer)dispatchHandle,
5529 lineRasterizationMode);
5530 android::base::endTrace();
5531 break;
5532 }
5533 case OP_vkCmdSetLineStippleEnableEXT: {
5534 android::base::beginTrace("vkCmdSetLineStippleEnableEXT subdecode");
5535 VkBool32 stippledLineEnable;
5536 memcpy((VkBool32*)&stippledLineEnable, *readStreamPtrPtr, sizeof(VkBool32));
5537 *readStreamPtrPtr += sizeof(VkBool32);
5538 vk->vkCmdSetLineStippleEnableEXT((VkCommandBuffer)dispatchHandle,
5539 stippledLineEnable);
5540 android::base::endTrace();
5541 break;
5542 }
5543 case OP_vkCmdSetDepthClipNegativeOneToOneEXT: {
5544 android::base::beginTrace("vkCmdSetDepthClipNegativeOneToOneEXT subdecode");
5545 VkBool32 negativeOneToOne;
5546 memcpy((VkBool32*)&negativeOneToOne, *readStreamPtrPtr, sizeof(VkBool32));
5547 *readStreamPtrPtr += sizeof(VkBool32);
5548 vk->vkCmdSetDepthClipNegativeOneToOneEXT((VkCommandBuffer)dispatchHandle,
5549 negativeOneToOne);
5550 android::base::endTrace();
5551 break;
5552 }
5553 case OP_vkCmdSetViewportWScalingEnableNV: {
5554 android::base::beginTrace("vkCmdSetViewportWScalingEnableNV subdecode");
5555 VkBool32 viewportWScalingEnable;
5556 memcpy((VkBool32*)&viewportWScalingEnable, *readStreamPtrPtr, sizeof(VkBool32));
5557 *readStreamPtrPtr += sizeof(VkBool32);
5558 vk->vkCmdSetViewportWScalingEnableNV((VkCommandBuffer)dispatchHandle,
5559 viewportWScalingEnable);
5560 android::base::endTrace();
5561 break;
5562 }
5563 case OP_vkCmdSetViewportSwizzleNV: {
5564 android::base::beginTrace("vkCmdSetViewportSwizzleNV subdecode");
5565 uint32_t firstViewport;
5566 uint32_t viewportCount;
5567 const VkViewportSwizzleNV* pViewportSwizzles;
5568 VkViewportSwizzleNV stack_pViewportSwizzles[MAX_STACK_ITEMS];
5569 memcpy((uint32_t*)&firstViewport, *readStreamPtrPtr, sizeof(uint32_t));
5570 *readStreamPtrPtr += sizeof(uint32_t);
5571 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
5572 *readStreamPtrPtr += sizeof(uint32_t);
5573 if (((viewportCount)) <= MAX_STACK_ITEMS) {
5574 pViewportSwizzles = (VkViewportSwizzleNV*)stack_pViewportSwizzles;
5575 } else {
5576 readStream->alloc((void**)&pViewportSwizzles,
5577 ((viewportCount)) * sizeof(const VkViewportSwizzleNV));
5578 }
5579 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
5580 reservedunmarshal_VkViewportSwizzleNV(
5581 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5582 (VkViewportSwizzleNV*)(pViewportSwizzles + i), readStreamPtrPtr);
5583 }
5584 if (pViewportSwizzles) {
5585 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
5586 transform_tohost_VkViewportSwizzleNV(
5587 globalstate, (VkViewportSwizzleNV*)(pViewportSwizzles + i));
5588 }
5589 }
5590 vk->vkCmdSetViewportSwizzleNV((VkCommandBuffer)dispatchHandle, firstViewport,
5591 viewportCount, pViewportSwizzles);
5592 android::base::endTrace();
5593 break;
5594 }
5595 case OP_vkCmdSetCoverageToColorEnableNV: {
5596 android::base::beginTrace("vkCmdSetCoverageToColorEnableNV subdecode");
5597 VkBool32 coverageToColorEnable;
5598 memcpy((VkBool32*)&coverageToColorEnable, *readStreamPtrPtr, sizeof(VkBool32));
5599 *readStreamPtrPtr += sizeof(VkBool32);
5600 vk->vkCmdSetCoverageToColorEnableNV((VkCommandBuffer)dispatchHandle,
5601 coverageToColorEnable);
5602 android::base::endTrace();
5603 break;
5604 }
5605 case OP_vkCmdSetCoverageToColorLocationNV: {
5606 android::base::beginTrace("vkCmdSetCoverageToColorLocationNV subdecode");
5607 uint32_t coverageToColorLocation;
5608 memcpy((uint32_t*)&coverageToColorLocation, *readStreamPtrPtr, sizeof(uint32_t));
5609 *readStreamPtrPtr += sizeof(uint32_t);
5610 vk->vkCmdSetCoverageToColorLocationNV((VkCommandBuffer)dispatchHandle,
5611 coverageToColorLocation);
5612 android::base::endTrace();
5613 break;
5614 }
5615 case OP_vkCmdSetCoverageModulationModeNV: {
5616 android::base::beginTrace("vkCmdSetCoverageModulationModeNV subdecode");
5617 VkCoverageModulationModeNV coverageModulationMode;
5618 memcpy((VkCoverageModulationModeNV*)&coverageModulationMode, *readStreamPtrPtr,
5619 sizeof(VkCoverageModulationModeNV));
5620 *readStreamPtrPtr += sizeof(VkCoverageModulationModeNV);
5621 vk->vkCmdSetCoverageModulationModeNV((VkCommandBuffer)dispatchHandle,
5622 coverageModulationMode);
5623 android::base::endTrace();
5624 break;
5625 }
5626 case OP_vkCmdSetCoverageModulationTableEnableNV: {
5627 android::base::beginTrace("vkCmdSetCoverageModulationTableEnableNV subdecode");
5628 VkBool32 coverageModulationTableEnable;
5629 memcpy((VkBool32*)&coverageModulationTableEnable, *readStreamPtrPtr,
5630 sizeof(VkBool32));
5631 *readStreamPtrPtr += sizeof(VkBool32);
5632 vk->vkCmdSetCoverageModulationTableEnableNV((VkCommandBuffer)dispatchHandle,
5633 coverageModulationTableEnable);
5634 android::base::endTrace();
5635 break;
5636 }
5637 case OP_vkCmdSetCoverageModulationTableNV: {
5638 android::base::beginTrace("vkCmdSetCoverageModulationTableNV subdecode");
5639 uint32_t coverageModulationTableCount;
5640 const float* pCoverageModulationTable;
5641 float stack_pCoverageModulationTable[MAX_STACK_ITEMS];
5642 memcpy((uint32_t*)&coverageModulationTableCount, *readStreamPtrPtr,
5643 sizeof(uint32_t));
5644 *readStreamPtrPtr += sizeof(uint32_t);
5645 if (((coverageModulationTableCount)) <= MAX_STACK_ITEMS) {
5646 pCoverageModulationTable = (float*)stack_pCoverageModulationTable;
5647 } else {
5648 readStream->alloc((void**)&pCoverageModulationTable,
5649 ((coverageModulationTableCount)) * sizeof(const float));
5650 }
5651 memcpy((float*)pCoverageModulationTable, *readStreamPtrPtr,
5652 ((coverageModulationTableCount)) * sizeof(const float));
5653 *readStreamPtrPtr += ((coverageModulationTableCount)) * sizeof(const float);
5654 vk->vkCmdSetCoverageModulationTableNV((VkCommandBuffer)dispatchHandle,
5655 coverageModulationTableCount,
5656 pCoverageModulationTable);
5657 android::base::endTrace();
5658 break;
5659 }
5660 case OP_vkCmdSetShadingRateImageEnableNV: {
5661 android::base::beginTrace("vkCmdSetShadingRateImageEnableNV subdecode");
5662 VkBool32 shadingRateImageEnable;
5663 memcpy((VkBool32*)&shadingRateImageEnable, *readStreamPtrPtr, sizeof(VkBool32));
5664 *readStreamPtrPtr += sizeof(VkBool32);
5665 vk->vkCmdSetShadingRateImageEnableNV((VkCommandBuffer)dispatchHandle,
5666 shadingRateImageEnable);
5667 android::base::endTrace();
5668 break;
5669 }
5670 case OP_vkCmdSetRepresentativeFragmentTestEnableNV: {
5671 android::base::beginTrace("vkCmdSetRepresentativeFragmentTestEnableNV subdecode");
5672 VkBool32 representativeFragmentTestEnable;
5673 memcpy((VkBool32*)&representativeFragmentTestEnable, *readStreamPtrPtr,
5674 sizeof(VkBool32));
5675 *readStreamPtrPtr += sizeof(VkBool32);
5676 vk->vkCmdSetRepresentativeFragmentTestEnableNV((VkCommandBuffer)dispatchHandle,
5677 representativeFragmentTestEnable);
5678 android::base::endTrace();
5679 break;
5680 }
5681 case OP_vkCmdSetCoverageReductionModeNV: {
5682 android::base::beginTrace("vkCmdSetCoverageReductionModeNV subdecode");
5683 VkCoverageReductionModeNV coverageReductionMode;
5684 memcpy((VkCoverageReductionModeNV*)&coverageReductionMode, *readStreamPtrPtr,
5685 sizeof(VkCoverageReductionModeNV));
5686 *readStreamPtrPtr += sizeof(VkCoverageReductionModeNV);
5687 vk->vkCmdSetCoverageReductionModeNV((VkCommandBuffer)dispatchHandle,
5688 coverageReductionMode);
5689 android::base::endTrace();
5690 break;
5691 }
5692 #endif
5693 #ifdef VK_EXT_subpass_merge_feedback
5694 #endif
5695 #ifdef VK_LUNARG_direct_driver_loading
5696 #endif
5697 #ifdef VK_EXT_shader_module_identifier
5698 #endif
5699 #ifdef VK_EXT_rasterization_order_attachment_access
5700 #endif
5701 #ifdef VK_NV_optical_flow
5702 case OP_vkCmdOpticalFlowExecuteNV: {
5703 android::base::beginTrace("vkCmdOpticalFlowExecuteNV subdecode");
5704 VkOpticalFlowSessionNV session;
5705 const VkOpticalFlowExecuteInfoNV* pExecuteInfo;
5706 VkOpticalFlowExecuteInfoNV stack_pExecuteInfo[1];
5707 memcpy((VkOpticalFlowSessionNV*)&session, (*readStreamPtrPtr), 8);
5708 android::base::Stream::fromBe64((uint8_t*)&session);
5709 *readStreamPtrPtr += 8;
5710 pExecuteInfo = (VkOpticalFlowExecuteInfoNV*)stack_pExecuteInfo;
5711 reservedunmarshal_VkOpticalFlowExecuteInfoNV(
5712 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5713 (VkOpticalFlowExecuteInfoNV*)(pExecuteInfo), readStreamPtrPtr);
5714 if (pExecuteInfo) {
5715 transform_tohost_VkOpticalFlowExecuteInfoNV(
5716 globalstate, (VkOpticalFlowExecuteInfoNV*)(pExecuteInfo));
5717 }
5718 vk->vkCmdOpticalFlowExecuteNV((VkCommandBuffer)dispatchHandle, session,
5719 pExecuteInfo);
5720 android::base::endTrace();
5721 break;
5722 }
5723 #endif
5724 #ifdef VK_EXT_legacy_dithering
5725 #endif
5726 #ifdef VK_EXT_pipeline_protected_access
5727 #endif
5728 #ifdef VK_EXT_shader_object
5729 case OP_vkCmdBindShadersEXT: {
5730 android::base::beginTrace("vkCmdBindShadersEXT subdecode");
5731 uint32_t stageCount;
5732 const VkShaderStageFlagBits* pStages;
5733 VkShaderStageFlagBits stack_pStages[MAX_STACK_ITEMS];
5734 const VkShaderEXT* pShaders;
5735 VkShaderEXT stack_pShaders[MAX_STACK_ITEMS];
5736 memcpy((uint32_t*)&stageCount, *readStreamPtrPtr, sizeof(uint32_t));
5737 *readStreamPtrPtr += sizeof(uint32_t);
5738 if (((stageCount)) <= MAX_STACK_ITEMS) {
5739 pStages = (VkShaderStageFlagBits*)stack_pStages;
5740 } else {
5741 readStream->alloc((void**)&pStages,
5742 ((stageCount)) * sizeof(const VkShaderStageFlagBits));
5743 }
5744 memcpy((VkShaderStageFlagBits*)pStages, *readStreamPtrPtr,
5745 ((stageCount)) * sizeof(const VkShaderStageFlagBits));
5746 *readStreamPtrPtr += ((stageCount)) * sizeof(const VkShaderStageFlagBits);
5747 // WARNING PTR CHECK
5748 memcpy((VkShaderEXT**)&pShaders, (*readStreamPtrPtr), 8);
5749 android::base::Stream::fromBe64((uint8_t*)&pShaders);
5750 *readStreamPtrPtr += 8;
5751 if (pShaders) {
5752 if (((stageCount)) <= MAX_STACK_ITEMS) {
5753 pShaders = (VkShaderEXT*)stack_pShaders;
5754 } else {
5755 readStream->alloc((void**)&pShaders,
5756 ((stageCount)) * sizeof(const VkShaderEXT));
5757 }
5758 for (uint32_t i = 0; i < (uint32_t)((stageCount)); ++i) {
5759 memcpy((VkShaderEXT*)&pShaders[i], (*readStreamPtrPtr), 8);
5760 android::base::Stream::fromBe64((uint8_t*)&pShaders[i]);
5761 *readStreamPtrPtr += 8;
5762 }
5763 }
5764 vk->vkCmdBindShadersEXT((VkCommandBuffer)dispatchHandle, stageCount, pStages,
5765 pShaders);
5766 android::base::endTrace();
5767 break;
5768 }
5769 #endif
5770 #ifdef VK_QCOM_tile_properties
5771 #endif
5772 #ifdef VK_SEC_amigo_profiling
5773 #endif
5774 #ifdef VK_QCOM_multiview_per_view_viewports
5775 #endif
5776 #ifdef VK_NV_ray_tracing_invocation_reorder
5777 #endif
5778 #ifdef VK_EXT_mutable_descriptor_type
5779 #endif
5780 #ifdef VK_ARM_shader_core_builtins
5781 #endif
5782 #ifdef VK_EXT_pipeline_library_group_handles
5783 #endif
5784 #ifdef VK_QCOM_multiview_per_view_render_areas
5785 #endif
5786 #ifdef VK_EXT_attachment_feedback_loop_dynamic_state
5787 case OP_vkCmdSetAttachmentFeedbackLoopEnableEXT: {
5788 android::base::beginTrace("vkCmdSetAttachmentFeedbackLoopEnableEXT subdecode");
5789 VkImageAspectFlags aspectMask;
5790 memcpy((VkImageAspectFlags*)&aspectMask, *readStreamPtrPtr,
5791 sizeof(VkImageAspectFlags));
5792 *readStreamPtrPtr += sizeof(VkImageAspectFlags);
5793 vk->vkCmdSetAttachmentFeedbackLoopEnableEXT((VkCommandBuffer)dispatchHandle,
5794 aspectMask);
5795 android::base::endTrace();
5796 break;
5797 }
5798 #endif
5799 #ifdef VK_KHR_acceleration_structure
5800 case OP_vkCmdBuildAccelerationStructuresKHR: {
5801 android::base::beginTrace("vkCmdBuildAccelerationStructuresKHR subdecode");
5802 uint32_t infoCount;
5803 const VkAccelerationStructureBuildGeometryInfoKHR* pInfos;
5804 VkAccelerationStructureBuildGeometryInfoKHR stack_pInfos[MAX_STACK_ITEMS];
5805 const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos;
5806 VkAccelerationStructureBuildRangeInfoKHR* stack_ppBuildRangeInfos[MAX_STACK_ITEMS];
5807 memcpy((uint32_t*)&infoCount, *readStreamPtrPtr, sizeof(uint32_t));
5808 *readStreamPtrPtr += sizeof(uint32_t);
5809 if (((infoCount)) <= MAX_STACK_ITEMS) {
5810 pInfos = (VkAccelerationStructureBuildGeometryInfoKHR*)stack_pInfos;
5811 } else {
5812 readStream->alloc(
5813 (void**)&pInfos,
5814 ((infoCount)) * sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
5815 }
5816 for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
5817 reservedunmarshal_VkAccelerationStructureBuildGeometryInfoKHR(
5818 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5819 (VkAccelerationStructureBuildGeometryInfoKHR*)(pInfos + i),
5820 readStreamPtrPtr);
5821 }
5822 if (pInfos) {
5823 for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
5824 transform_tohost_VkAccelerationStructureBuildGeometryInfoKHR(
5825 globalstate,
5826 (VkAccelerationStructureBuildGeometryInfoKHR*)(pInfos + i));
5827 }
5828 }
5829 (void)ppBuildRangeInfos;
5830 vk->vkCmdBuildAccelerationStructuresKHR((VkCommandBuffer)dispatchHandle, infoCount,
5831 pInfos, ppBuildRangeInfos);
5832 android::base::endTrace();
5833 break;
5834 }
5835 case OP_vkCmdBuildAccelerationStructuresIndirectKHR: {
5836 android::base::beginTrace("vkCmdBuildAccelerationStructuresIndirectKHR subdecode");
5837 uint32_t infoCount;
5838 const VkAccelerationStructureBuildGeometryInfoKHR* pInfos;
5839 VkAccelerationStructureBuildGeometryInfoKHR stack_pInfos[MAX_STACK_ITEMS];
5840 const VkDeviceAddress* pIndirectDeviceAddresses;
5841 VkDeviceAddress stack_pIndirectDeviceAddresses[MAX_STACK_ITEMS];
5842 const uint32_t* pIndirectStrides;
5843 uint32_t stack_pIndirectStrides[MAX_STACK_ITEMS];
5844 const uint32_t* const* ppMaxPrimitiveCounts;
5845 uint32_t* stack_ppMaxPrimitiveCounts[MAX_STACK_ITEMS];
5846 memcpy((uint32_t*)&infoCount, *readStreamPtrPtr, sizeof(uint32_t));
5847 *readStreamPtrPtr += sizeof(uint32_t);
5848 if (((infoCount)) <= MAX_STACK_ITEMS) {
5849 pInfos = (VkAccelerationStructureBuildGeometryInfoKHR*)stack_pInfos;
5850 } else {
5851 readStream->alloc(
5852 (void**)&pInfos,
5853 ((infoCount)) * sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
5854 }
5855 for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
5856 reservedunmarshal_VkAccelerationStructureBuildGeometryInfoKHR(
5857 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5858 (VkAccelerationStructureBuildGeometryInfoKHR*)(pInfos + i),
5859 readStreamPtrPtr);
5860 }
5861 if (((infoCount)) <= MAX_STACK_ITEMS) {
5862 pIndirectDeviceAddresses = (VkDeviceAddress*)stack_pIndirectDeviceAddresses;
5863 } else {
5864 readStream->alloc((void**)&pIndirectDeviceAddresses,
5865 ((infoCount)) * sizeof(const VkDeviceAddress));
5866 }
5867 memcpy((VkDeviceAddress*)pIndirectDeviceAddresses, *readStreamPtrPtr,
5868 ((infoCount)) * sizeof(const VkDeviceAddress));
5869 *readStreamPtrPtr += ((infoCount)) * sizeof(const VkDeviceAddress);
5870 if (((infoCount)) <= MAX_STACK_ITEMS) {
5871 pIndirectStrides = (uint32_t*)stack_pIndirectStrides;
5872 } else {
5873 readStream->alloc((void**)&pIndirectStrides,
5874 ((infoCount)) * sizeof(const uint32_t));
5875 }
5876 memcpy((uint32_t*)pIndirectStrides, *readStreamPtrPtr,
5877 ((infoCount)) * sizeof(const uint32_t));
5878 *readStreamPtrPtr += ((infoCount)) * sizeof(const uint32_t);
5879 if (pInfos) {
5880 for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
5881 transform_tohost_VkAccelerationStructureBuildGeometryInfoKHR(
5882 globalstate,
5883 (VkAccelerationStructureBuildGeometryInfoKHR*)(pInfos + i));
5884 }
5885 }
5886 (void)ppMaxPrimitiveCounts;
5887 vk->vkCmdBuildAccelerationStructuresIndirectKHR(
5888 (VkCommandBuffer)dispatchHandle, infoCount, pInfos, pIndirectDeviceAddresses,
5889 pIndirectStrides, ppMaxPrimitiveCounts);
5890 android::base::endTrace();
5891 break;
5892 }
5893 case OP_vkCmdCopyAccelerationStructureKHR: {
5894 android::base::beginTrace("vkCmdCopyAccelerationStructureKHR subdecode");
5895 const VkCopyAccelerationStructureInfoKHR* pInfo;
5896 VkCopyAccelerationStructureInfoKHR stack_pInfo[1];
5897 pInfo = (VkCopyAccelerationStructureInfoKHR*)stack_pInfo;
5898 reservedunmarshal_VkCopyAccelerationStructureInfoKHR(
5899 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5900 (VkCopyAccelerationStructureInfoKHR*)(pInfo), readStreamPtrPtr);
5901 if (pInfo) {
5902 transform_tohost_VkCopyAccelerationStructureInfoKHR(
5903 globalstate, (VkCopyAccelerationStructureInfoKHR*)(pInfo));
5904 }
5905 vk->vkCmdCopyAccelerationStructureKHR((VkCommandBuffer)dispatchHandle, pInfo);
5906 android::base::endTrace();
5907 break;
5908 }
5909 case OP_vkCmdCopyAccelerationStructureToMemoryKHR: {
5910 android::base::beginTrace("vkCmdCopyAccelerationStructureToMemoryKHR subdecode");
5911 const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo;
5912 VkCopyAccelerationStructureToMemoryInfoKHR stack_pInfo[1];
5913 pInfo = (VkCopyAccelerationStructureToMemoryInfoKHR*)stack_pInfo;
5914 reservedunmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(
5915 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5916 (VkCopyAccelerationStructureToMemoryInfoKHR*)(pInfo), readStreamPtrPtr);
5917 if (pInfo) {
5918 transform_tohost_VkCopyAccelerationStructureToMemoryInfoKHR(
5919 globalstate, (VkCopyAccelerationStructureToMemoryInfoKHR*)(pInfo));
5920 }
5921 vk->vkCmdCopyAccelerationStructureToMemoryKHR((VkCommandBuffer)dispatchHandle,
5922 pInfo);
5923 android::base::endTrace();
5924 break;
5925 }
5926 case OP_vkCmdCopyMemoryToAccelerationStructureKHR: {
5927 android::base::beginTrace("vkCmdCopyMemoryToAccelerationStructureKHR subdecode");
5928 const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo;
5929 VkCopyMemoryToAccelerationStructureInfoKHR stack_pInfo[1];
5930 pInfo = (VkCopyMemoryToAccelerationStructureInfoKHR*)stack_pInfo;
5931 reservedunmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(
5932 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
5933 (VkCopyMemoryToAccelerationStructureInfoKHR*)(pInfo), readStreamPtrPtr);
5934 if (pInfo) {
5935 transform_tohost_VkCopyMemoryToAccelerationStructureInfoKHR(
5936 globalstate, (VkCopyMemoryToAccelerationStructureInfoKHR*)(pInfo));
5937 }
5938 vk->vkCmdCopyMemoryToAccelerationStructureKHR((VkCommandBuffer)dispatchHandle,
5939 pInfo);
5940 android::base::endTrace();
5941 break;
5942 }
5943 case OP_vkCmdWriteAccelerationStructuresPropertiesKHR: {
5944 android::base::beginTrace(
5945 "vkCmdWriteAccelerationStructuresPropertiesKHR subdecode");
5946 uint32_t accelerationStructureCount;
5947 const VkAccelerationStructureKHR* pAccelerationStructures;
5948 VkAccelerationStructureKHR stack_pAccelerationStructures[MAX_STACK_ITEMS];
5949 VkQueryType queryType;
5950 VkQueryPool queryPool;
5951 uint32_t firstQuery;
5952 memcpy((uint32_t*)&accelerationStructureCount, *readStreamPtrPtr, sizeof(uint32_t));
5953 *readStreamPtrPtr += sizeof(uint32_t);
5954 if (((accelerationStructureCount)) <= MAX_STACK_ITEMS) {
5955 pAccelerationStructures =
5956 (VkAccelerationStructureKHR*)stack_pAccelerationStructures;
5957 } else {
5958 readStream->alloc(
5959 (void**)&pAccelerationStructures,
5960 ((accelerationStructureCount)) * sizeof(const VkAccelerationStructureKHR));
5961 }
5962 if (((accelerationStructureCount))) {
5963 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
5964 *readStreamPtrPtr += 8 * ((accelerationStructureCount));
5965 for (uint32_t k = 0; k < ((accelerationStructureCount)); ++k) {
5966 uint64_t tmpval;
5967 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
5968 *(((VkAccelerationStructureKHR*)pAccelerationStructures) + k) =
5969 (VkAccelerationStructureKHR)unbox_VkAccelerationStructureKHR(
5970 (VkAccelerationStructureKHR)tmpval);
5971 }
5972 }
5973 memcpy((VkQueryType*)&queryType, *readStreamPtrPtr, sizeof(VkQueryType));
5974 *readStreamPtrPtr += sizeof(VkQueryType);
5975 uint64_t cgen_var_1;
5976 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
5977 *readStreamPtrPtr += 1 * 8;
5978 *(VkQueryPool*)&queryPool =
5979 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
5980 memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
5981 *readStreamPtrPtr += sizeof(uint32_t);
5982 vk->vkCmdWriteAccelerationStructuresPropertiesKHR(
5983 (VkCommandBuffer)dispatchHandle, accelerationStructureCount,
5984 pAccelerationStructures, queryType, queryPool, firstQuery);
5985 android::base::endTrace();
5986 break;
5987 }
5988 #endif
5989 #ifdef VK_KHR_ray_tracing_pipeline
5990 case OP_vkCmdTraceRaysKHR: {
5991 android::base::beginTrace("vkCmdTraceRaysKHR subdecode");
5992 const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable;
5993 VkStridedDeviceAddressRegionKHR stack_pRaygenShaderBindingTable[1];
5994 const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable;
5995 VkStridedDeviceAddressRegionKHR stack_pMissShaderBindingTable[1];
5996 const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable;
5997 VkStridedDeviceAddressRegionKHR stack_pHitShaderBindingTable[1];
5998 const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable;
5999 VkStridedDeviceAddressRegionKHR stack_pCallableShaderBindingTable[1];
6000 uint32_t width;
6001 uint32_t height;
6002 uint32_t depth;
6003 pRaygenShaderBindingTable =
6004 (VkStridedDeviceAddressRegionKHR*)stack_pRaygenShaderBindingTable;
6005 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
6006 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
6007 (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable),
6008 readStreamPtrPtr);
6009 pMissShaderBindingTable =
6010 (VkStridedDeviceAddressRegionKHR*)stack_pMissShaderBindingTable;
6011 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
6012 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
6013 (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable), readStreamPtrPtr);
6014 pHitShaderBindingTable =
6015 (VkStridedDeviceAddressRegionKHR*)stack_pHitShaderBindingTable;
6016 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
6017 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
6018 (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable), readStreamPtrPtr);
6019 pCallableShaderBindingTable =
6020 (VkStridedDeviceAddressRegionKHR*)stack_pCallableShaderBindingTable;
6021 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
6022 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
6023 (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable),
6024 readStreamPtrPtr);
6025 memcpy((uint32_t*)&width, *readStreamPtrPtr, sizeof(uint32_t));
6026 *readStreamPtrPtr += sizeof(uint32_t);
6027 memcpy((uint32_t*)&height, *readStreamPtrPtr, sizeof(uint32_t));
6028 *readStreamPtrPtr += sizeof(uint32_t);
6029 memcpy((uint32_t*)&depth, *readStreamPtrPtr, sizeof(uint32_t));
6030 *readStreamPtrPtr += sizeof(uint32_t);
6031 if (pRaygenShaderBindingTable) {
6032 transform_tohost_VkStridedDeviceAddressRegionKHR(
6033 globalstate, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable));
6034 }
6035 if (pMissShaderBindingTable) {
6036 transform_tohost_VkStridedDeviceAddressRegionKHR(
6037 globalstate, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable));
6038 }
6039 if (pHitShaderBindingTable) {
6040 transform_tohost_VkStridedDeviceAddressRegionKHR(
6041 globalstate, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable));
6042 }
6043 if (pCallableShaderBindingTable) {
6044 transform_tohost_VkStridedDeviceAddressRegionKHR(
6045 globalstate,
6046 (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable));
6047 }
6048 vk->vkCmdTraceRaysKHR((VkCommandBuffer)dispatchHandle, pRaygenShaderBindingTable,
6049 pMissShaderBindingTable, pHitShaderBindingTable,
6050 pCallableShaderBindingTable, width, height, depth);
6051 android::base::endTrace();
6052 break;
6053 }
6054 case OP_vkCmdTraceRaysIndirectKHR: {
6055 android::base::beginTrace("vkCmdTraceRaysIndirectKHR subdecode");
6056 const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable;
6057 VkStridedDeviceAddressRegionKHR stack_pRaygenShaderBindingTable[1];
6058 const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable;
6059 VkStridedDeviceAddressRegionKHR stack_pMissShaderBindingTable[1];
6060 const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable;
6061 VkStridedDeviceAddressRegionKHR stack_pHitShaderBindingTable[1];
6062 const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable;
6063 VkStridedDeviceAddressRegionKHR stack_pCallableShaderBindingTable[1];
6064 VkDeviceAddress indirectDeviceAddress;
6065 pRaygenShaderBindingTable =
6066 (VkStridedDeviceAddressRegionKHR*)stack_pRaygenShaderBindingTable;
6067 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
6068 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
6069 (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable),
6070 readStreamPtrPtr);
6071 pMissShaderBindingTable =
6072 (VkStridedDeviceAddressRegionKHR*)stack_pMissShaderBindingTable;
6073 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
6074 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
6075 (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable), readStreamPtrPtr);
6076 pHitShaderBindingTable =
6077 (VkStridedDeviceAddressRegionKHR*)stack_pHitShaderBindingTable;
6078 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
6079 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
6080 (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable), readStreamPtrPtr);
6081 pCallableShaderBindingTable =
6082 (VkStridedDeviceAddressRegionKHR*)stack_pCallableShaderBindingTable;
6083 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
6084 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
6085 (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable),
6086 readStreamPtrPtr);
6087 memcpy((VkDeviceAddress*)&indirectDeviceAddress, *readStreamPtrPtr,
6088 sizeof(VkDeviceAddress));
6089 *readStreamPtrPtr += sizeof(VkDeviceAddress);
6090 if (pRaygenShaderBindingTable) {
6091 transform_tohost_VkStridedDeviceAddressRegionKHR(
6092 globalstate, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable));
6093 }
6094 if (pMissShaderBindingTable) {
6095 transform_tohost_VkStridedDeviceAddressRegionKHR(
6096 globalstate, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable));
6097 }
6098 if (pHitShaderBindingTable) {
6099 transform_tohost_VkStridedDeviceAddressRegionKHR(
6100 globalstate, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable));
6101 }
6102 if (pCallableShaderBindingTable) {
6103 transform_tohost_VkStridedDeviceAddressRegionKHR(
6104 globalstate,
6105 (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable));
6106 }
6107 vk->vkCmdTraceRaysIndirectKHR((VkCommandBuffer)dispatchHandle,
6108 pRaygenShaderBindingTable, pMissShaderBindingTable,
6109 pHitShaderBindingTable, pCallableShaderBindingTable,
6110 indirectDeviceAddress);
6111 android::base::endTrace();
6112 break;
6113 }
6114 case OP_vkCmdSetRayTracingPipelineStackSizeKHR: {
6115 android::base::beginTrace("vkCmdSetRayTracingPipelineStackSizeKHR subdecode");
6116 uint32_t pipelineStackSize;
6117 memcpy((uint32_t*)&pipelineStackSize, *readStreamPtrPtr, sizeof(uint32_t));
6118 *readStreamPtrPtr += sizeof(uint32_t);
6119 vk->vkCmdSetRayTracingPipelineStackSizeKHR((VkCommandBuffer)dispatchHandle,
6120 pipelineStackSize);
6121 android::base::endTrace();
6122 break;
6123 }
6124 #endif
6125 #ifdef VK_KHR_ray_query
6126 #endif
6127 #ifdef VK_EXT_mesh_shader
6128 case OP_vkCmdDrawMeshTasksEXT: {
6129 android::base::beginTrace("vkCmdDrawMeshTasksEXT subdecode");
6130 uint32_t groupCountX;
6131 uint32_t groupCountY;
6132 uint32_t groupCountZ;
6133 memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
6134 *readStreamPtrPtr += sizeof(uint32_t);
6135 memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
6136 *readStreamPtrPtr += sizeof(uint32_t);
6137 memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
6138 *readStreamPtrPtr += sizeof(uint32_t);
6139 vk->vkCmdDrawMeshTasksEXT((VkCommandBuffer)dispatchHandle, groupCountX, groupCountY,
6140 groupCountZ);
6141 android::base::endTrace();
6142 break;
6143 }
6144 case OP_vkCmdDrawMeshTasksIndirectEXT: {
6145 android::base::beginTrace("vkCmdDrawMeshTasksIndirectEXT subdecode");
6146 VkBuffer buffer;
6147 VkDeviceSize offset;
6148 uint32_t drawCount;
6149 uint32_t stride;
6150 uint64_t cgen_var_0;
6151 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6152 *readStreamPtrPtr += 1 * 8;
6153 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
6154 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
6155 *readStreamPtrPtr += sizeof(VkDeviceSize);
6156 memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
6157 *readStreamPtrPtr += sizeof(uint32_t);
6158 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
6159 *readStreamPtrPtr += sizeof(uint32_t);
6160 vk->vkCmdDrawMeshTasksIndirectEXT((VkCommandBuffer)dispatchHandle, buffer, offset,
6161 drawCount, stride);
6162 android::base::endTrace();
6163 break;
6164 }
6165 case OP_vkCmdDrawMeshTasksIndirectCountEXT: {
6166 android::base::beginTrace("vkCmdDrawMeshTasksIndirectCountEXT subdecode");
6167 VkBuffer buffer;
6168 VkDeviceSize offset;
6169 VkBuffer countBuffer;
6170 VkDeviceSize countBufferOffset;
6171 uint32_t maxDrawCount;
6172 uint32_t stride;
6173 uint64_t cgen_var_0;
6174 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
6175 *readStreamPtrPtr += 1 * 8;
6176 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
6177 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
6178 *readStreamPtrPtr += sizeof(VkDeviceSize);
6179 uint64_t cgen_var_1;
6180 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
6181 *readStreamPtrPtr += 1 * 8;
6182 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
6183 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
6184 *readStreamPtrPtr += sizeof(VkDeviceSize);
6185 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
6186 *readStreamPtrPtr += sizeof(uint32_t);
6187 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
6188 *readStreamPtrPtr += sizeof(uint32_t);
6189 vk->vkCmdDrawMeshTasksIndirectCountEXT((VkCommandBuffer)dispatchHandle, buffer,
6190 offset, countBuffer, countBufferOffset,
6191 maxDrawCount, stride);
6192 android::base::endTrace();
6193 break;
6194 }
6195 #endif
6196 default: {
6197 GFXSTREAM_ABORT(::emugl::FatalError(::emugl::ABORT_REASON_OTHER))
6198 << "Unrecognized opcode " << opcode;
6199 }
6200 }
6201 ++count;
6202 if (count % 1000 == 0) {
6203 pool->freeAll();
6204 };
6205 ptr += packetLen;
6206 }
6207 pool->freeAll();
6208 return ptr - (unsigned char*)buf;
6209 ;
6210 }
6211