1 // Generated Code - DO NOT EDIT !!
2 // generated by 'emugen'
3
4
5 #include <string.h>
6 #include "magma_opcodes.h"
7
8 #include "magma_dec.h"
9
10
11 #include "ProtocolUtils.h"
12
13 #include "ChecksumCalculatorThreadInfo.h"
14
15 #include "host-common/logging.h"
16
17 #include <stdio.h>
18
19 namespace gfxstream {
20
21 typedef unsigned int tsize_t; // Target "size_t", which is 32-bit for now. It may or may not be the same as host's size_t when emugen is compiled.
22
23 #ifdef CHECK_GL_ERRORS
24 # define SET_LASTCALL(name) sprintf(lastCall, #name)
25 #else
26 # define SET_LASTCALL(name)
27 #endif
decode(void * buf,size_t len,IOStream * stream,ChecksumCalculator * checksumCalc)28 size_t magma_decoder_context_t::decode(void *buf, size_t len, IOStream *stream, ChecksumCalculator* checksumCalc) {
29 if (len < 8) return 0;
30 #ifdef CHECK_GL_ERRORS
31 char lastCall[256] = {0};
32 #endif
33 unsigned char *ptr = (unsigned char *)buf;
34 const unsigned char* const end = (const unsigned char*)buf + len;
35 const size_t checksumSize = checksumCalc->checksumByteSize();
36 const bool useChecksum = checksumSize > 0;
37 while (end - ptr >= 8) {
38 uint32_t opcode = *(uint32_t *)ptr;
39 uint32_t packetLen = *(uint32_t *)(ptr + 4);
40 if (end - ptr < packetLen) return ptr - (unsigned char*)buf;
41 switch(opcode) {
42 case OP_magma_device_import: {
43 android::base::beginTrace("magma_device_import decode");
44 magma_handle_t var_device_channel = Unpack<magma_handle_t,uint32_t>(ptr + 8);
45 uint32_t size_device_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
46 if (useChecksum) {
47 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
48 "magma_decoder_context_t::decode, OP_magma_device_import: GL checksumCalculator failure\n");
49 }
50 size_t totalTmpSize = size_device_out;
51 totalTmpSize += sizeof(magma_status_t);
52 totalTmpSize += checksumSize;
53 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
54 OutputBuffer outptr_device_out(&tmpBuf[0], size_device_out);
55 DECODER_DEBUG_LOG("magma(%p): magma_device_import(device_channel:%u device_out:%p(%u) )", stream, var_device_channel, (magma_device_t*)(outptr_device_out.get()), size_device_out);
56 *(magma_status_t *)(&tmpBuf[0 + size_device_out]) = this->magma_device_import(var_device_channel, (magma_device_t*)(outptr_device_out.get()));
57 outptr_device_out.flush();
58 if (useChecksum) {
59 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
60 }
61 stream->flush();
62 SET_LASTCALL("magma_device_import");
63 android::base::endTrace();
64 break;
65 }
66 case OP_magma_device_release: {
67 android::base::beginTrace("magma_device_release decode");
68 magma_device_t var_device = Unpack<magma_device_t,uint64_t>(ptr + 8);
69 if (useChecksum) {
70 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8, ptr + 8 + 8, checksumSize,
71 "magma_decoder_context_t::decode, OP_magma_device_release: GL checksumCalculator failure\n");
72 }
73 DECODER_DEBUG_LOG("magma(%p): magma_device_release(device:%lu )", stream, var_device);
74 this->magma_device_release(var_device);
75 SET_LASTCALL("magma_device_release");
76 android::base::endTrace();
77 break;
78 }
79 case OP_magma_device_query: {
80 android::base::beginTrace("magma_device_query decode");
81 magma_device_t var_device = Unpack<magma_device_t,uint64_t>(ptr + 8);
82 uint64_t var_id = Unpack<uint64_t,uint64_t>(ptr + 8 + 8);
83 uint32_t size_result_buffer_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 8);
84 uint32_t size_result_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 8 + 4);
85 if (useChecksum) {
86 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 8 + 4 + 4, ptr + 8 + 8 + 8 + 4 + 4, checksumSize,
87 "magma_decoder_context_t::decode, OP_magma_device_query: GL checksumCalculator failure\n");
88 }
89 size_t totalTmpSize = size_result_buffer_out;
90 totalTmpSize += size_result_out;
91 totalTmpSize += sizeof(magma_status_t);
92 totalTmpSize += checksumSize;
93 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
94 OutputBuffer outptr_result_buffer_out(&tmpBuf[0], size_result_buffer_out);
95 OutputBuffer outptr_result_out(&tmpBuf[0 + size_result_buffer_out], size_result_out);
96 DECODER_DEBUG_LOG("magma(%p): magma_device_query(device:%lu id:%lu result_buffer_out:%p(%u) result_out:%p(%u) )", stream, var_device, var_id, (magma_handle_t*)(outptr_result_buffer_out.get()), size_result_buffer_out, (uint64_t*)(outptr_result_out.get()), size_result_out);
97 *(magma_status_t *)(&tmpBuf[0 + size_result_buffer_out + size_result_out]) = this->magma_device_query(var_device, var_id, (magma_handle_t*)(outptr_result_buffer_out.get()), (uint64_t*)(outptr_result_out.get()));
98 outptr_result_buffer_out.flush();
99 outptr_result_out.flush();
100 if (useChecksum) {
101 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
102 }
103 stream->flush();
104 SET_LASTCALL("magma_device_query");
105 android::base::endTrace();
106 break;
107 }
108 case OP_magma_device_query_fudge: {
109 android::base::beginTrace("magma_device_query_fudge decode");
110 magma_device_t var_device = Unpack<magma_device_t,uint64_t>(ptr + 8);
111 uint64_t var_id = Unpack<uint64_t,uint64_t>(ptr + 8 + 8);
112 magma_bool_t var_host_allocate = Unpack<magma_bool_t,uint8_t>(ptr + 8 + 8 + 8);
113 uint32_t size_result_buffer_mapping_id_inout __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 8 + 1);
114 InputBuffer inptr_result_buffer_mapping_id_inout(ptr + 8 + 8 + 8 + 1 + 4, size_result_buffer_mapping_id_inout);
115 uint32_t size_result_buffer_size_inout __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 8 + 1 + 4 + size_result_buffer_mapping_id_inout);
116 InputBuffer inptr_result_buffer_size_inout(ptr + 8 + 8 + 8 + 1 + 4 + size_result_buffer_mapping_id_inout + 4, size_result_buffer_size_inout);
117 uint32_t size_result_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 8 + 1 + 4 + size_result_buffer_mapping_id_inout + 4 + size_result_buffer_size_inout);
118 if (useChecksum) {
119 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 8 + 1 + 4 + size_result_buffer_mapping_id_inout + 4 + size_result_buffer_size_inout + 4, ptr + 8 + 8 + 8 + 1 + 4 + size_result_buffer_mapping_id_inout + 4 + size_result_buffer_size_inout + 4, checksumSize,
120 "magma_decoder_context_t::decode, OP_magma_device_query_fudge: GL checksumCalculator failure\n");
121 }
122 size_t totalTmpSize = size_result_buffer_mapping_id_inout;
123 totalTmpSize += size_result_buffer_size_inout;
124 totalTmpSize += size_result_out;
125 totalTmpSize += sizeof(magma_status_t);
126 totalTmpSize += checksumSize;
127 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
128 OutputBuffer outptr_result_buffer_mapping_id_inout(&tmpBuf[0], size_result_buffer_mapping_id_inout);
129 memcpy(outptr_result_buffer_mapping_id_inout.get(), inptr_result_buffer_mapping_id_inout.get(), size_result_buffer_mapping_id_inout);
130 OutputBuffer outptr_result_buffer_size_inout(&tmpBuf[0 + size_result_buffer_mapping_id_inout], size_result_buffer_size_inout);
131 memcpy(outptr_result_buffer_size_inout.get(), inptr_result_buffer_size_inout.get(), size_result_buffer_size_inout);
132 OutputBuffer outptr_result_out(&tmpBuf[0 + size_result_buffer_mapping_id_inout + size_result_buffer_size_inout], size_result_out);
133 DECODER_DEBUG_LOG("magma(%p): magma_device_query_fudge(device:%lu id:%lu host_allocate:%hhu result_buffer_mapping_id_inout:%p(%u) result_buffer_size_inout:%p(%u) result_out:%p(%u) )", stream, var_device, var_id, var_host_allocate, (uint64_t*)(outptr_result_buffer_mapping_id_inout.get()), size_result_buffer_mapping_id_inout, (uint64_t*)(outptr_result_buffer_size_inout.get()), size_result_buffer_size_inout, (uint64_t*)(outptr_result_out.get()), size_result_out);
134 *(magma_status_t *)(&tmpBuf[0 + size_result_buffer_mapping_id_inout + size_result_buffer_size_inout + size_result_out]) = this->magma_device_query_fudge(var_device, var_id, var_host_allocate, (uint64_t*)(outptr_result_buffer_mapping_id_inout.get()), (uint64_t*)(outptr_result_buffer_size_inout.get()), (uint64_t*)(outptr_result_out.get()));
135 outptr_result_buffer_mapping_id_inout.flush();
136 outptr_result_buffer_size_inout.flush();
137 outptr_result_out.flush();
138 if (useChecksum) {
139 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
140 }
141 stream->flush();
142 SET_LASTCALL("magma_device_query_fudge");
143 android::base::endTrace();
144 break;
145 }
146 case OP_magma_device_create_connection: {
147 android::base::beginTrace("magma_device_create_connection decode");
148 magma_device_t var_device = Unpack<magma_device_t,uint64_t>(ptr + 8);
149 uint32_t size_connection_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
150 if (useChecksum) {
151 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4, ptr + 8 + 8 + 4, checksumSize,
152 "magma_decoder_context_t::decode, OP_magma_device_create_connection: GL checksumCalculator failure\n");
153 }
154 size_t totalTmpSize = size_connection_out;
155 totalTmpSize += sizeof(magma_status_t);
156 totalTmpSize += checksumSize;
157 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
158 OutputBuffer outptr_connection_out(&tmpBuf[0], size_connection_out);
159 DECODER_DEBUG_LOG("magma(%p): magma_device_create_connection(device:%lu connection_out:%p(%u) )", stream, var_device, (magma_connection_t*)(outptr_connection_out.get()), size_connection_out);
160 *(magma_status_t *)(&tmpBuf[0 + size_connection_out]) = this->magma_device_create_connection(var_device, (magma_connection_t*)(outptr_connection_out.get()));
161 outptr_connection_out.flush();
162 if (useChecksum) {
163 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
164 }
165 stream->flush();
166 SET_LASTCALL("magma_device_create_connection");
167 android::base::endTrace();
168 break;
169 }
170 case OP_magma_connection_release: {
171 android::base::beginTrace("magma_connection_release decode");
172 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
173 if (useChecksum) {
174 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8, ptr + 8 + 8, checksumSize,
175 "magma_decoder_context_t::decode, OP_magma_connection_release: GL checksumCalculator failure\n");
176 }
177 DECODER_DEBUG_LOG("magma(%p): magma_connection_release(connection:%lu )", stream, var_connection);
178 this->magma_connection_release(var_connection);
179 SET_LASTCALL("magma_connection_release");
180 android::base::endTrace();
181 break;
182 }
183 case OP_magma_connection_get_error: {
184 android::base::beginTrace("magma_connection_get_error decode");
185 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
186 if (useChecksum) {
187 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8, ptr + 8 + 8, checksumSize,
188 "magma_decoder_context_t::decode, OP_magma_connection_get_error: GL checksumCalculator failure\n");
189 }
190 size_t totalTmpSize = sizeof(magma_status_t);
191 totalTmpSize += checksumSize;
192 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
193 DECODER_DEBUG_LOG("magma(%p): magma_connection_get_error(connection:%lu )", stream, var_connection);
194 *(magma_status_t *)(&tmpBuf[0]) = this->magma_connection_get_error(var_connection);
195 if (useChecksum) {
196 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
197 }
198 stream->flush();
199 SET_LASTCALL("magma_connection_get_error");
200 android::base::endTrace();
201 break;
202 }
203 case OP_magma_connection_create_context: {
204 android::base::beginTrace("magma_connection_create_context decode");
205 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
206 uint32_t size_context_id_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
207 if (useChecksum) {
208 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4, ptr + 8 + 8 + 4, checksumSize,
209 "magma_decoder_context_t::decode, OP_magma_connection_create_context: GL checksumCalculator failure\n");
210 }
211 size_t totalTmpSize = size_context_id_out;
212 totalTmpSize += sizeof(magma_status_t);
213 totalTmpSize += checksumSize;
214 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
215 OutputBuffer outptr_context_id_out(&tmpBuf[0], size_context_id_out);
216 DECODER_DEBUG_LOG("magma(%p): magma_connection_create_context(connection:%lu context_id_out:%p(%u) )", stream, var_connection, (uint32_t*)(outptr_context_id_out.get()), size_context_id_out);
217 *(magma_status_t *)(&tmpBuf[0 + size_context_id_out]) = this->magma_connection_create_context(var_connection, (uint32_t*)(outptr_context_id_out.get()));
218 outptr_context_id_out.flush();
219 if (useChecksum) {
220 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
221 }
222 stream->flush();
223 SET_LASTCALL("magma_connection_create_context");
224 android::base::endTrace();
225 break;
226 }
227 case OP_magma_connection_release_context: {
228 android::base::beginTrace("magma_connection_release_context decode");
229 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
230 uint32_t var_context_id = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
231 if (useChecksum) {
232 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4, ptr + 8 + 8 + 4, checksumSize,
233 "magma_decoder_context_t::decode, OP_magma_connection_release_context: GL checksumCalculator failure\n");
234 }
235 DECODER_DEBUG_LOG("magma(%p): magma_connection_release_context(connection:%lu context_id:%u )", stream, var_connection, var_context_id);
236 this->magma_connection_release_context(var_connection, var_context_id);
237 SET_LASTCALL("magma_connection_release_context");
238 android::base::endTrace();
239 break;
240 }
241 case OP_magma_connection_create_buffer: {
242 android::base::beginTrace("magma_connection_create_buffer decode");
243 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
244 uint64_t var_size = Unpack<uint64_t,uint64_t>(ptr + 8 + 8);
245 uint32_t size_size_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 8);
246 uint32_t size_buffer_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 8 + 4);
247 uint32_t size_id_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 8 + 4 + 4);
248 if (useChecksum) {
249 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 8 + 4 + 4 + 4, ptr + 8 + 8 + 8 + 4 + 4 + 4, checksumSize,
250 "magma_decoder_context_t::decode, OP_magma_connection_create_buffer: GL checksumCalculator failure\n");
251 }
252 size_t totalTmpSize = size_size_out;
253 totalTmpSize += size_buffer_out;
254 totalTmpSize += size_id_out;
255 totalTmpSize += sizeof(magma_status_t);
256 totalTmpSize += checksumSize;
257 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
258 OutputBuffer outptr_size_out(&tmpBuf[0], size_size_out);
259 OutputBuffer outptr_buffer_out(&tmpBuf[0 + size_size_out], size_buffer_out);
260 OutputBuffer outptr_id_out(&tmpBuf[0 + size_size_out + size_buffer_out], size_id_out);
261 DECODER_DEBUG_LOG("magma(%p): magma_connection_create_buffer(connection:%lu size:%lu size_out:%p(%u) buffer_out:%p(%u) id_out:%p(%u) )", stream, var_connection, var_size, (uint64_t*)(outptr_size_out.get()), size_size_out, (magma_buffer_t*)(outptr_buffer_out.get()), size_buffer_out, (magma_buffer_id_t*)(outptr_id_out.get()), size_id_out);
262 *(magma_status_t *)(&tmpBuf[0 + size_size_out + size_buffer_out + size_id_out]) = this->magma_connection_create_buffer(var_connection, var_size, (uint64_t*)(outptr_size_out.get()), (magma_buffer_t*)(outptr_buffer_out.get()), (magma_buffer_id_t*)(outptr_id_out.get()));
263 outptr_size_out.flush();
264 outptr_buffer_out.flush();
265 outptr_id_out.flush();
266 if (useChecksum) {
267 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
268 }
269 stream->flush();
270 SET_LASTCALL("magma_connection_create_buffer");
271 android::base::endTrace();
272 break;
273 }
274 case OP_magma_connection_release_buffer: {
275 android::base::beginTrace("magma_connection_release_buffer decode");
276 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
277 magma_buffer_t var_buffer = Unpack<magma_buffer_t,uint64_t>(ptr + 8 + 8);
278 if (useChecksum) {
279 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 8, ptr + 8 + 8 + 8, checksumSize,
280 "magma_decoder_context_t::decode, OP_magma_connection_release_buffer: GL checksumCalculator failure\n");
281 }
282 DECODER_DEBUG_LOG("magma(%p): magma_connection_release_buffer(connection:%lu buffer:%lu )", stream, var_connection, var_buffer);
283 this->magma_connection_release_buffer(var_connection, var_buffer);
284 SET_LASTCALL("magma_connection_release_buffer");
285 android::base::endTrace();
286 break;
287 }
288 case OP_magma_connection_import_buffer: {
289 android::base::beginTrace("magma_connection_import_buffer decode");
290 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
291 magma_handle_t var_buffer_handle = Unpack<magma_handle_t,uint32_t>(ptr + 8 + 8);
292 uint32_t size_size_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 4);
293 uint32_t size_buffer_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 4 + 4);
294 uint32_t size_id_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 4 + 4 + 4);
295 if (useChecksum) {
296 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + 4 + 4 + 4, ptr + 8 + 8 + 4 + 4 + 4 + 4, checksumSize,
297 "magma_decoder_context_t::decode, OP_magma_connection_import_buffer: GL checksumCalculator failure\n");
298 }
299 size_t totalTmpSize = size_size_out;
300 totalTmpSize += size_buffer_out;
301 totalTmpSize += size_id_out;
302 totalTmpSize += sizeof(magma_status_t);
303 totalTmpSize += checksumSize;
304 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
305 OutputBuffer outptr_size_out(&tmpBuf[0], size_size_out);
306 OutputBuffer outptr_buffer_out(&tmpBuf[0 + size_size_out], size_buffer_out);
307 OutputBuffer outptr_id_out(&tmpBuf[0 + size_size_out + size_buffer_out], size_id_out);
308 DECODER_DEBUG_LOG("magma(%p): magma_connection_import_buffer(connection:%lu buffer_handle:%u size_out:%p(%u) buffer_out:%p(%u) id_out:%p(%u) )", stream, var_connection, var_buffer_handle, (uint64_t*)(outptr_size_out.get()), size_size_out, (magma_buffer_t*)(outptr_buffer_out.get()), size_buffer_out, (magma_buffer_id_t*)(outptr_id_out.get()), size_id_out);
309 *(magma_status_t *)(&tmpBuf[0 + size_size_out + size_buffer_out + size_id_out]) = this->magma_connection_import_buffer(var_connection, var_buffer_handle, (uint64_t*)(outptr_size_out.get()), (magma_buffer_t*)(outptr_buffer_out.get()), (magma_buffer_id_t*)(outptr_id_out.get()));
310 outptr_size_out.flush();
311 outptr_buffer_out.flush();
312 outptr_id_out.flush();
313 if (useChecksum) {
314 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
315 }
316 stream->flush();
317 SET_LASTCALL("magma_connection_import_buffer");
318 android::base::endTrace();
319 break;
320 }
321 case OP_magma_connection_create_semaphore: {
322 android::base::beginTrace("magma_connection_create_semaphore decode");
323 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
324 uint32_t size_semaphore_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
325 uint32_t size_id_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 4);
326 if (useChecksum) {
327 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + 4, ptr + 8 + 8 + 4 + 4, checksumSize,
328 "magma_decoder_context_t::decode, OP_magma_connection_create_semaphore: GL checksumCalculator failure\n");
329 }
330 size_t totalTmpSize = size_semaphore_out;
331 totalTmpSize += size_id_out;
332 totalTmpSize += sizeof(magma_status_t);
333 totalTmpSize += checksumSize;
334 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
335 OutputBuffer outptr_semaphore_out(&tmpBuf[0], size_semaphore_out);
336 OutputBuffer outptr_id_out(&tmpBuf[0 + size_semaphore_out], size_id_out);
337 DECODER_DEBUG_LOG("magma(%p): magma_connection_create_semaphore(connection:%lu semaphore_out:%p(%u) id_out:%p(%u) )", stream, var_connection, (magma_semaphore_t*)(outptr_semaphore_out.get()), size_semaphore_out, (magma_semaphore_id_t*)(outptr_id_out.get()), size_id_out);
338 *(magma_status_t *)(&tmpBuf[0 + size_semaphore_out + size_id_out]) = this->magma_connection_create_semaphore(var_connection, (magma_semaphore_t*)(outptr_semaphore_out.get()), (magma_semaphore_id_t*)(outptr_id_out.get()));
339 outptr_semaphore_out.flush();
340 outptr_id_out.flush();
341 if (useChecksum) {
342 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
343 }
344 stream->flush();
345 SET_LASTCALL("magma_connection_create_semaphore");
346 android::base::endTrace();
347 break;
348 }
349 case OP_magma_connection_release_semaphore: {
350 android::base::beginTrace("magma_connection_release_semaphore decode");
351 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
352 magma_semaphore_t var_semaphore = Unpack<magma_semaphore_t,uint64_t>(ptr + 8 + 8);
353 if (useChecksum) {
354 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 8, ptr + 8 + 8 + 8, checksumSize,
355 "magma_decoder_context_t::decode, OP_magma_connection_release_semaphore: GL checksumCalculator failure\n");
356 }
357 DECODER_DEBUG_LOG("magma(%p): magma_connection_release_semaphore(connection:%lu semaphore:%lu )", stream, var_connection, var_semaphore);
358 this->magma_connection_release_semaphore(var_connection, var_semaphore);
359 SET_LASTCALL("magma_connection_release_semaphore");
360 android::base::endTrace();
361 break;
362 }
363 case OP_magma_connection_import_semaphore: {
364 android::base::beginTrace("magma_connection_import_semaphore decode");
365 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
366 magma_handle_t var_semaphore_handle = Unpack<magma_handle_t,uint32_t>(ptr + 8 + 8);
367 uint32_t size_semaphore_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 4);
368 uint32_t size_id_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 4 + 4);
369 if (useChecksum) {
370 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + 4 + 4, ptr + 8 + 8 + 4 + 4 + 4, checksumSize,
371 "magma_decoder_context_t::decode, OP_magma_connection_import_semaphore: GL checksumCalculator failure\n");
372 }
373 size_t totalTmpSize = size_semaphore_out;
374 totalTmpSize += size_id_out;
375 totalTmpSize += sizeof(magma_status_t);
376 totalTmpSize += checksumSize;
377 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
378 OutputBuffer outptr_semaphore_out(&tmpBuf[0], size_semaphore_out);
379 OutputBuffer outptr_id_out(&tmpBuf[0 + size_semaphore_out], size_id_out);
380 DECODER_DEBUG_LOG("magma(%p): magma_connection_import_semaphore(connection:%lu semaphore_handle:%u semaphore_out:%p(%u) id_out:%p(%u) )", stream, var_connection, var_semaphore_handle, (magma_semaphore_t*)(outptr_semaphore_out.get()), size_semaphore_out, (magma_semaphore_id_t*)(outptr_id_out.get()), size_id_out);
381 *(magma_status_t *)(&tmpBuf[0 + size_semaphore_out + size_id_out]) = this->magma_connection_import_semaphore(var_connection, var_semaphore_handle, (magma_semaphore_t*)(outptr_semaphore_out.get()), (magma_semaphore_id_t*)(outptr_id_out.get()));
382 outptr_semaphore_out.flush();
383 outptr_id_out.flush();
384 if (useChecksum) {
385 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
386 }
387 stream->flush();
388 SET_LASTCALL("magma_connection_import_semaphore");
389 android::base::endTrace();
390 break;
391 }
392 case OP_magma_connection_perform_buffer_op: {
393 android::base::beginTrace("magma_connection_perform_buffer_op decode");
394 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
395 magma_buffer_t var_buffer = Unpack<magma_buffer_t,uint64_t>(ptr + 8 + 8);
396 uint32_t var_options = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 8);
397 uint64_t var_start_offset = Unpack<uint64_t,uint64_t>(ptr + 8 + 8 + 8 + 4);
398 uint64_t var_length = Unpack<uint64_t,uint64_t>(ptr + 8 + 8 + 8 + 4 + 8);
399 if (useChecksum) {
400 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 8 + 4 + 8 + 8, ptr + 8 + 8 + 8 + 4 + 8 + 8, checksumSize,
401 "magma_decoder_context_t::decode, OP_magma_connection_perform_buffer_op: GL checksumCalculator failure\n");
402 }
403 size_t totalTmpSize = sizeof(magma_status_t);
404 totalTmpSize += checksumSize;
405 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
406 DECODER_DEBUG_LOG("magma(%p): magma_connection_perform_buffer_op(connection:%lu buffer:%lu options:%u start_offset:%lu length:%lu )", stream, var_connection, var_buffer, var_options, var_start_offset, var_length);
407 *(magma_status_t *)(&tmpBuf[0]) = this->magma_connection_perform_buffer_op(var_connection, var_buffer, var_options, var_start_offset, var_length);
408 if (useChecksum) {
409 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
410 }
411 stream->flush();
412 SET_LASTCALL("magma_connection_perform_buffer_op");
413 android::base::endTrace();
414 break;
415 }
416 case OP_magma_connection_map_buffer: {
417 android::base::beginTrace("magma_connection_map_buffer decode");
418 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
419 uint64_t var_hw_va = Unpack<uint64_t,uint64_t>(ptr + 8 + 8);
420 magma_buffer_t var_buffer = Unpack<magma_buffer_t,uint64_t>(ptr + 8 + 8 + 8);
421 uint64_t var_offset = Unpack<uint64_t,uint64_t>(ptr + 8 + 8 + 8 + 8);
422 uint64_t var_length = Unpack<uint64_t,uint64_t>(ptr + 8 + 8 + 8 + 8 + 8);
423 uint64_t var_map_flags = Unpack<uint64_t,uint64_t>(ptr + 8 + 8 + 8 + 8 + 8 + 8);
424 if (useChecksum) {
425 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 8 + 8 + 8 + 8 + 8, ptr + 8 + 8 + 8 + 8 + 8 + 8 + 8, checksumSize,
426 "magma_decoder_context_t::decode, OP_magma_connection_map_buffer: GL checksumCalculator failure\n");
427 }
428 size_t totalTmpSize = sizeof(magma_status_t);
429 totalTmpSize += checksumSize;
430 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
431 DECODER_DEBUG_LOG("magma(%p): magma_connection_map_buffer(connection:%lu hw_va:%lu buffer:%lu offset:%lu length:%lu map_flags:%lu )", stream, var_connection, var_hw_va, var_buffer, var_offset, var_length, var_map_flags);
432 *(magma_status_t *)(&tmpBuf[0]) = this->magma_connection_map_buffer(var_connection, var_hw_va, var_buffer, var_offset, var_length, var_map_flags);
433 if (useChecksum) {
434 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
435 }
436 stream->flush();
437 SET_LASTCALL("magma_connection_map_buffer");
438 android::base::endTrace();
439 break;
440 }
441 case OP_magma_connection_unmap_buffer: {
442 android::base::beginTrace("magma_connection_unmap_buffer decode");
443 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
444 uint64_t var_hw_va = Unpack<uint64_t,uint64_t>(ptr + 8 + 8);
445 magma_buffer_t var_buffer = Unpack<magma_buffer_t,uint64_t>(ptr + 8 + 8 + 8);
446 if (useChecksum) {
447 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 8 + 8, ptr + 8 + 8 + 8 + 8, checksumSize,
448 "magma_decoder_context_t::decode, OP_magma_connection_unmap_buffer: GL checksumCalculator failure\n");
449 }
450 DECODER_DEBUG_LOG("magma(%p): magma_connection_unmap_buffer(connection:%lu hw_va:%lu buffer:%lu )", stream, var_connection, var_hw_va, var_buffer);
451 this->magma_connection_unmap_buffer(var_connection, var_hw_va, var_buffer);
452 SET_LASTCALL("magma_connection_unmap_buffer");
453 android::base::endTrace();
454 break;
455 }
456 case OP_magma_connection_execute_command: {
457 android::base::beginTrace("magma_connection_execute_command decode");
458 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
459 uint32_t var_context_id = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
460 uint32_t size_descriptor __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 4);
461 InputBuffer inptr_descriptor(ptr + 8 + 8 + 4 + 4, size_descriptor);
462 if (useChecksum) {
463 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + 4 + size_descriptor, ptr + 8 + 8 + 4 + 4 + size_descriptor, checksumSize,
464 "magma_decoder_context_t::decode, OP_magma_connection_execute_command: GL checksumCalculator failure\n");
465 }
466 size_t totalTmpSize = sizeof(magma_status_t);
467 totalTmpSize += checksumSize;
468 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
469 DECODER_DEBUG_LOG("magma(%p): magma_connection_execute_command(connection:%lu context_id:%u descriptor:%p(%u) )", stream, var_connection, var_context_id, (magma_command_descriptor_t*)(inptr_descriptor.get()), size_descriptor);
470 *(magma_status_t *)(&tmpBuf[0]) = this->magma_connection_execute_command(var_connection, var_context_id, (magma_command_descriptor_t*)(inptr_descriptor.get()));
471 if (useChecksum) {
472 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
473 }
474 stream->flush();
475 SET_LASTCALL("magma_connection_execute_command");
476 android::base::endTrace();
477 break;
478 }
479 case OP_magma_connection_execute_command_fudge: {
480 android::base::beginTrace("magma_connection_execute_command_fudge decode");
481 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
482 uint32_t var_context_id = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
483 uint32_t size_descriptor __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 4);
484 InputBuffer inptr_descriptor(ptr + 8 + 8 + 4 + 4, size_descriptor);
485 uint64_t var_descriptor_size = Unpack<uint64_t,uint64_t>(ptr + 8 + 8 + 4 + 4 + size_descriptor);
486 if (useChecksum) {
487 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + 4 + size_descriptor + 8, ptr + 8 + 8 + 4 + 4 + size_descriptor + 8, checksumSize,
488 "magma_decoder_context_t::decode, OP_magma_connection_execute_command_fudge: GL checksumCalculator failure\n");
489 }
490 size_t totalTmpSize = sizeof(magma_status_t);
491 totalTmpSize += checksumSize;
492 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
493 DECODER_DEBUG_LOG("magma(%p): magma_connection_execute_command_fudge(connection:%lu context_id:%u descriptor:%p(%u) descriptor_size:%lu )", stream, var_connection, var_context_id, (void*)(inptr_descriptor.get()), size_descriptor, var_descriptor_size);
494 *(magma_status_t *)(&tmpBuf[0]) = this->magma_connection_execute_command_fudge(var_connection, var_context_id, (void*)(inptr_descriptor.get()), var_descriptor_size);
495 if (useChecksum) {
496 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
497 }
498 stream->flush();
499 SET_LASTCALL("magma_connection_execute_command_fudge");
500 android::base::endTrace();
501 break;
502 }
503 case OP_magma_connection_execute_immediate_commands: {
504 android::base::beginTrace("magma_connection_execute_immediate_commands decode");
505 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
506 uint32_t var_context_id = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
507 uint64_t var_command_count = Unpack<uint64_t,uint64_t>(ptr + 8 + 8 + 4);
508 uint32_t size_command_buffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 4 + 8);
509 InputBuffer inptr_command_buffers(ptr + 8 + 8 + 4 + 8 + 4, size_command_buffers);
510 if (useChecksum) {
511 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + 8 + 4 + size_command_buffers, ptr + 8 + 8 + 4 + 8 + 4 + size_command_buffers, checksumSize,
512 "magma_decoder_context_t::decode, OP_magma_connection_execute_immediate_commands: GL checksumCalculator failure\n");
513 }
514 size_t totalTmpSize = sizeof(magma_status_t);
515 totalTmpSize += checksumSize;
516 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
517 DECODER_DEBUG_LOG("magma(%p): magma_connection_execute_immediate_commands(connection:%lu context_id:%u command_count:%lu command_buffers:%p(%u) )", stream, var_connection, var_context_id, var_command_count, (magma_inline_command_buffer_t*)(inptr_command_buffers.get()), size_command_buffers);
518 *(magma_status_t *)(&tmpBuf[0]) = this->magma_connection_execute_immediate_commands(var_connection, var_context_id, var_command_count, (magma_inline_command_buffer_t*)(inptr_command_buffers.get()));
519 if (useChecksum) {
520 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
521 }
522 stream->flush();
523 SET_LASTCALL("magma_connection_execute_immediate_commands");
524 android::base::endTrace();
525 break;
526 }
527 case OP_magma_connection_execute_immediate_commands_fudge: {
528 android::base::beginTrace("magma_connection_execute_immediate_commands_fudge decode");
529 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
530 uint32_t var_context_id = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
531 uint64_t var_command_count = Unpack<uint64_t,uint64_t>(ptr + 8 + 8 + 4);
532 uint32_t size_command_buffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 4 + 8);
533 InputBuffer inptr_command_buffers(ptr + 8 + 8 + 4 + 8 + 4, size_command_buffers);
534 uint64_t var_command_buffers_size = Unpack<uint64_t,uint64_t>(ptr + 8 + 8 + 4 + 8 + 4 + size_command_buffers);
535 uint32_t size_command_buffer_offsets __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 4 + 8 + 4 + size_command_buffers + 8);
536 InputBuffer inptr_command_buffer_offsets(ptr + 8 + 8 + 4 + 8 + 4 + size_command_buffers + 8 + 4, size_command_buffer_offsets);
537 if (useChecksum) {
538 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + 8 + 4 + size_command_buffers + 8 + 4 + size_command_buffer_offsets, ptr + 8 + 8 + 4 + 8 + 4 + size_command_buffers + 8 + 4 + size_command_buffer_offsets, checksumSize,
539 "magma_decoder_context_t::decode, OP_magma_connection_execute_immediate_commands_fudge: GL checksumCalculator failure\n");
540 }
541 size_t totalTmpSize = sizeof(magma_status_t);
542 totalTmpSize += checksumSize;
543 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
544 DECODER_DEBUG_LOG("magma(%p): magma_connection_execute_immediate_commands_fudge(connection:%lu context_id:%u command_count:%lu command_buffers:%p(%u) command_buffers_size:%lu command_buffer_offsets:%p(%u) )", stream, var_connection, var_context_id, var_command_count, (void*)(inptr_command_buffers.get()), size_command_buffers, var_command_buffers_size, (uint64_t*)(inptr_command_buffer_offsets.get()), size_command_buffer_offsets);
545 *(magma_status_t *)(&tmpBuf[0]) = this->magma_connection_execute_immediate_commands_fudge(var_connection, var_context_id, var_command_count, (void*)(inptr_command_buffers.get()), var_command_buffers_size, (uint64_t*)(inptr_command_buffer_offsets.get()));
546 if (useChecksum) {
547 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
548 }
549 stream->flush();
550 SET_LASTCALL("magma_connection_execute_immediate_commands_fudge");
551 android::base::endTrace();
552 break;
553 }
554 case OP_magma_connection_flush: {
555 android::base::beginTrace("magma_connection_flush decode");
556 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
557 if (useChecksum) {
558 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8, ptr + 8 + 8, checksumSize,
559 "magma_decoder_context_t::decode, OP_magma_connection_flush: GL checksumCalculator failure\n");
560 }
561 size_t totalTmpSize = sizeof(magma_status_t);
562 totalTmpSize += checksumSize;
563 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
564 DECODER_DEBUG_LOG("magma(%p): magma_connection_flush(connection:%lu )", stream, var_connection);
565 *(magma_status_t *)(&tmpBuf[0]) = this->magma_connection_flush(var_connection);
566 if (useChecksum) {
567 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
568 }
569 stream->flush();
570 SET_LASTCALL("magma_connection_flush");
571 android::base::endTrace();
572 break;
573 }
574 case OP_magma_connection_get_notification_channel_handle: {
575 android::base::beginTrace("magma_connection_get_notification_channel_handle decode");
576 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
577 if (useChecksum) {
578 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8, ptr + 8 + 8, checksumSize,
579 "magma_decoder_context_t::decode, OP_magma_connection_get_notification_channel_handle: GL checksumCalculator failure\n");
580 }
581 size_t totalTmpSize = sizeof(magma_handle_t);
582 totalTmpSize += checksumSize;
583 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
584 DECODER_DEBUG_LOG("magma(%p): magma_connection_get_notification_channel_handle(connection:%lu )", stream, var_connection);
585 *(magma_handle_t *)(&tmpBuf[0]) = this->magma_connection_get_notification_channel_handle(var_connection);
586 if (useChecksum) {
587 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
588 }
589 stream->flush();
590 SET_LASTCALL("magma_connection_get_notification_channel_handle");
591 android::base::endTrace();
592 break;
593 }
594 case OP_magma_connection_read_notification_channel: {
595 android::base::beginTrace("magma_connection_read_notification_channel decode");
596 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
597 uint32_t size_buffer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
598 uint64_t var_buffer_size = Unpack<uint64_t,uint64_t>(ptr + 8 + 8 + 4);
599 uint32_t size_buffer_size_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 4 + 8);
600 uint32_t size_more_data_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 4 + 8 + 4);
601 if (useChecksum) {
602 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + 8 + 4 + 4, ptr + 8 + 8 + 4 + 8 + 4 + 4, checksumSize,
603 "magma_decoder_context_t::decode, OP_magma_connection_read_notification_channel: GL checksumCalculator failure\n");
604 }
605 size_t totalTmpSize = size_buffer;
606 totalTmpSize += size_buffer_size_out;
607 totalTmpSize += size_more_data_out;
608 totalTmpSize += sizeof(magma_status_t);
609 totalTmpSize += checksumSize;
610 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
611 OutputBuffer outptr_buffer(&tmpBuf[0], size_buffer);
612 OutputBuffer outptr_buffer_size_out(&tmpBuf[0 + size_buffer], size_buffer_size_out);
613 OutputBuffer outptr_more_data_out(&tmpBuf[0 + size_buffer + size_buffer_size_out], size_more_data_out);
614 DECODER_DEBUG_LOG("magma(%p): magma_connection_read_notification_channel(connection:%lu buffer:%p(%u) buffer_size:%lu buffer_size_out:%p(%u) more_data_out:%p(%u) )", stream, var_connection, (void*)(outptr_buffer.get()), size_buffer, var_buffer_size, (uint64_t*)(outptr_buffer_size_out.get()), size_buffer_size_out, (magma_bool_t*)(outptr_more_data_out.get()), size_more_data_out);
615 *(magma_status_t *)(&tmpBuf[0 + size_buffer + size_buffer_size_out + size_more_data_out]) = this->magma_connection_read_notification_channel(var_connection, (void*)(outptr_buffer.get()), var_buffer_size, (uint64_t*)(outptr_buffer_size_out.get()), (magma_bool_t*)(outptr_more_data_out.get()));
616 outptr_buffer.flush();
617 outptr_buffer_size_out.flush();
618 outptr_more_data_out.flush();
619 if (useChecksum) {
620 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
621 }
622 stream->flush();
623 SET_LASTCALL("magma_connection_read_notification_channel");
624 android::base::endTrace();
625 break;
626 }
627 case OP_magma_buffer_clean_cache: {
628 android::base::beginTrace("magma_buffer_clean_cache decode");
629 magma_buffer_t var_buffer = Unpack<magma_buffer_t,uint64_t>(ptr + 8);
630 uint64_t var_offset = Unpack<uint64_t,uint64_t>(ptr + 8 + 8);
631 uint64_t var_size = Unpack<uint64_t,uint64_t>(ptr + 8 + 8 + 8);
632 magma_cache_operation_t var_operation = Unpack<magma_cache_operation_t,uint32_t>(ptr + 8 + 8 + 8 + 8);
633 if (useChecksum) {
634 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 8 + 8 + 4, ptr + 8 + 8 + 8 + 8 + 4, checksumSize,
635 "magma_decoder_context_t::decode, OP_magma_buffer_clean_cache: GL checksumCalculator failure\n");
636 }
637 size_t totalTmpSize = sizeof(magma_status_t);
638 totalTmpSize += checksumSize;
639 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
640 DECODER_DEBUG_LOG("magma(%p): magma_buffer_clean_cache(buffer:%lu offset:%lu size:%lu operation:%u )", stream, var_buffer, var_offset, var_size, var_operation);
641 *(magma_status_t *)(&tmpBuf[0]) = this->magma_buffer_clean_cache(var_buffer, var_offset, var_size, var_operation);
642 if (useChecksum) {
643 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
644 }
645 stream->flush();
646 SET_LASTCALL("magma_buffer_clean_cache");
647 android::base::endTrace();
648 break;
649 }
650 case OP_magma_buffer_set_cache_policy: {
651 android::base::beginTrace("magma_buffer_set_cache_policy decode");
652 magma_buffer_t var_buffer = Unpack<magma_buffer_t,uint64_t>(ptr + 8);
653 magma_cache_policy_t var_policy = Unpack<magma_cache_policy_t,uint32_t>(ptr + 8 + 8);
654 if (useChecksum) {
655 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4, ptr + 8 + 8 + 4, checksumSize,
656 "magma_decoder_context_t::decode, OP_magma_buffer_set_cache_policy: GL checksumCalculator failure\n");
657 }
658 size_t totalTmpSize = sizeof(magma_status_t);
659 totalTmpSize += checksumSize;
660 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
661 DECODER_DEBUG_LOG("magma(%p): magma_buffer_set_cache_policy(buffer:%lu policy:%u )", stream, var_buffer, var_policy);
662 *(magma_status_t *)(&tmpBuf[0]) = this->magma_buffer_set_cache_policy(var_buffer, var_policy);
663 if (useChecksum) {
664 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
665 }
666 stream->flush();
667 SET_LASTCALL("magma_buffer_set_cache_policy");
668 android::base::endTrace();
669 break;
670 }
671 case OP_magma_buffer_get_cache_policy: {
672 android::base::beginTrace("magma_buffer_get_cache_policy decode");
673 magma_buffer_t var_buffer = Unpack<magma_buffer_t,uint64_t>(ptr + 8);
674 uint32_t size_cache_policy_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
675 if (useChecksum) {
676 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4, ptr + 8 + 8 + 4, checksumSize,
677 "magma_decoder_context_t::decode, OP_magma_buffer_get_cache_policy: GL checksumCalculator failure\n");
678 }
679 size_t totalTmpSize = size_cache_policy_out;
680 totalTmpSize += sizeof(magma_status_t);
681 totalTmpSize += checksumSize;
682 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
683 OutputBuffer outptr_cache_policy_out(&tmpBuf[0], size_cache_policy_out);
684 DECODER_DEBUG_LOG("magma(%p): magma_buffer_get_cache_policy(buffer:%lu cache_policy_out:%p(%u) )", stream, var_buffer, (magma_cache_policy_t*)(outptr_cache_policy_out.get()), size_cache_policy_out);
685 *(magma_status_t *)(&tmpBuf[0 + size_cache_policy_out]) = this->magma_buffer_get_cache_policy(var_buffer, (magma_cache_policy_t*)(outptr_cache_policy_out.get()));
686 outptr_cache_policy_out.flush();
687 if (useChecksum) {
688 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
689 }
690 stream->flush();
691 SET_LASTCALL("magma_buffer_get_cache_policy");
692 android::base::endTrace();
693 break;
694 }
695 case OP_magma_buffer_set_name: {
696 android::base::beginTrace("magma_buffer_set_name decode");
697 magma_buffer_t var_buffer = Unpack<magma_buffer_t,uint64_t>(ptr + 8);
698 uint32_t size_name __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
699 InputBuffer inptr_name(ptr + 8 + 8 + 4, size_name);
700 if (useChecksum) {
701 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + size_name, ptr + 8 + 8 + 4 + size_name, checksumSize,
702 "magma_decoder_context_t::decode, OP_magma_buffer_set_name: GL checksumCalculator failure\n");
703 }
704 size_t totalTmpSize = sizeof(magma_status_t);
705 totalTmpSize += checksumSize;
706 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
707 DECODER_DEBUG_LOG("magma(%p): magma_buffer_set_name(buffer:%lu name:%p(%u) )", stream, var_buffer, (const char*)(inptr_name.get()), size_name);
708 *(magma_status_t *)(&tmpBuf[0]) = this->magma_buffer_set_name(var_buffer, (const char*)(inptr_name.get()));
709 if (useChecksum) {
710 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
711 }
712 stream->flush();
713 SET_LASTCALL("magma_buffer_set_name");
714 android::base::endTrace();
715 break;
716 }
717 case OP_magma_buffer_set_name_fudge: {
718 android::base::beginTrace("magma_buffer_set_name_fudge decode");
719 magma_buffer_t var_buffer = Unpack<magma_buffer_t,uint64_t>(ptr + 8);
720 uint32_t size_name __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
721 InputBuffer inptr_name(ptr + 8 + 8 + 4, size_name);
722 uint64_t var_name_size = Unpack<uint64_t,uint64_t>(ptr + 8 + 8 + 4 + size_name);
723 if (useChecksum) {
724 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + size_name + 8, ptr + 8 + 8 + 4 + size_name + 8, checksumSize,
725 "magma_decoder_context_t::decode, OP_magma_buffer_set_name_fudge: GL checksumCalculator failure\n");
726 }
727 size_t totalTmpSize = sizeof(magma_status_t);
728 totalTmpSize += checksumSize;
729 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
730 DECODER_DEBUG_LOG("magma(%p): magma_buffer_set_name_fudge(buffer:%lu name:%p(%u) name_size:%lu )", stream, var_buffer, (void*)(inptr_name.get()), size_name, var_name_size);
731 *(magma_status_t *)(&tmpBuf[0]) = this->magma_buffer_set_name_fudge(var_buffer, (void*)(inptr_name.get()), var_name_size);
732 if (useChecksum) {
733 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
734 }
735 stream->flush();
736 SET_LASTCALL("magma_buffer_set_name_fudge");
737 android::base::endTrace();
738 break;
739 }
740 case OP_magma_buffer_get_info: {
741 android::base::beginTrace("magma_buffer_get_info decode");
742 magma_buffer_t var_buffer = Unpack<magma_buffer_t,uint64_t>(ptr + 8);
743 uint32_t size_info_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
744 if (useChecksum) {
745 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4, ptr + 8 + 8 + 4, checksumSize,
746 "magma_decoder_context_t::decode, OP_magma_buffer_get_info: GL checksumCalculator failure\n");
747 }
748 size_t totalTmpSize = size_info_out;
749 totalTmpSize += sizeof(magma_status_t);
750 totalTmpSize += checksumSize;
751 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
752 OutputBuffer outptr_info_out(&tmpBuf[0], size_info_out);
753 DECODER_DEBUG_LOG("magma(%p): magma_buffer_get_info(buffer:%lu info_out:%p(%u) )", stream, var_buffer, (magma_buffer_info_t*)(outptr_info_out.get()), size_info_out);
754 *(magma_status_t *)(&tmpBuf[0 + size_info_out]) = this->magma_buffer_get_info(var_buffer, (magma_buffer_info_t*)(outptr_info_out.get()));
755 outptr_info_out.flush();
756 if (useChecksum) {
757 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
758 }
759 stream->flush();
760 SET_LASTCALL("magma_buffer_get_info");
761 android::base::endTrace();
762 break;
763 }
764 case OP_magma_buffer_get_handle: {
765 android::base::beginTrace("magma_buffer_get_handle decode");
766 magma_buffer_t var_buffer = Unpack<magma_buffer_t,uint64_t>(ptr + 8);
767 uint32_t size_handle_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
768 if (useChecksum) {
769 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4, ptr + 8 + 8 + 4, checksumSize,
770 "magma_decoder_context_t::decode, OP_magma_buffer_get_handle: GL checksumCalculator failure\n");
771 }
772 size_t totalTmpSize = size_handle_out;
773 totalTmpSize += sizeof(magma_status_t);
774 totalTmpSize += checksumSize;
775 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
776 OutputBuffer outptr_handle_out(&tmpBuf[0], size_handle_out);
777 DECODER_DEBUG_LOG("magma(%p): magma_buffer_get_handle(buffer:%lu handle_out:%p(%u) )", stream, var_buffer, (magma_handle_t*)(outptr_handle_out.get()), size_handle_out);
778 *(magma_status_t *)(&tmpBuf[0 + size_handle_out]) = this->magma_buffer_get_handle(var_buffer, (magma_handle_t*)(outptr_handle_out.get()));
779 outptr_handle_out.flush();
780 if (useChecksum) {
781 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
782 }
783 stream->flush();
784 SET_LASTCALL("magma_buffer_get_handle");
785 android::base::endTrace();
786 break;
787 }
788 case OP_magma_buffer_export: {
789 android::base::beginTrace("magma_buffer_export decode");
790 magma_buffer_t var_buffer = Unpack<magma_buffer_t,uint64_t>(ptr + 8);
791 uint32_t size_buffer_handle_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
792 if (useChecksum) {
793 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4, ptr + 8 + 8 + 4, checksumSize,
794 "magma_decoder_context_t::decode, OP_magma_buffer_export: GL checksumCalculator failure\n");
795 }
796 size_t totalTmpSize = size_buffer_handle_out;
797 totalTmpSize += sizeof(magma_status_t);
798 totalTmpSize += checksumSize;
799 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
800 OutputBuffer outptr_buffer_handle_out(&tmpBuf[0], size_buffer_handle_out);
801 DECODER_DEBUG_LOG("magma(%p): magma_buffer_export(buffer:%lu buffer_handle_out:%p(%u) )", stream, var_buffer, (magma_handle_t*)(outptr_buffer_handle_out.get()), size_buffer_handle_out);
802 *(magma_status_t *)(&tmpBuf[0 + size_buffer_handle_out]) = this->magma_buffer_export(var_buffer, (magma_handle_t*)(outptr_buffer_handle_out.get()));
803 outptr_buffer_handle_out.flush();
804 if (useChecksum) {
805 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
806 }
807 stream->flush();
808 SET_LASTCALL("magma_buffer_export");
809 android::base::endTrace();
810 break;
811 }
812 case OP_magma_semaphore_signal: {
813 android::base::beginTrace("magma_semaphore_signal decode");
814 magma_semaphore_t var_semaphore = Unpack<magma_semaphore_t,uint64_t>(ptr + 8);
815 if (useChecksum) {
816 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8, ptr + 8 + 8, checksumSize,
817 "magma_decoder_context_t::decode, OP_magma_semaphore_signal: GL checksumCalculator failure\n");
818 }
819 DECODER_DEBUG_LOG("magma(%p): magma_semaphore_signal(semaphore:%lu )", stream, var_semaphore);
820 this->magma_semaphore_signal(var_semaphore);
821 SET_LASTCALL("magma_semaphore_signal");
822 android::base::endTrace();
823 break;
824 }
825 case OP_magma_semaphore_reset: {
826 android::base::beginTrace("magma_semaphore_reset decode");
827 magma_semaphore_t var_semaphore = Unpack<magma_semaphore_t,uint64_t>(ptr + 8);
828 if (useChecksum) {
829 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8, ptr + 8 + 8, checksumSize,
830 "magma_decoder_context_t::decode, OP_magma_semaphore_reset: GL checksumCalculator failure\n");
831 }
832 DECODER_DEBUG_LOG("magma(%p): magma_semaphore_reset(semaphore:%lu )", stream, var_semaphore);
833 this->magma_semaphore_reset(var_semaphore);
834 SET_LASTCALL("magma_semaphore_reset");
835 android::base::endTrace();
836 break;
837 }
838 case OP_magma_semaphore_export: {
839 android::base::beginTrace("magma_semaphore_export decode");
840 magma_semaphore_t var_semaphore = Unpack<magma_semaphore_t,uint64_t>(ptr + 8);
841 uint32_t size_semaphore_handle_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
842 if (useChecksum) {
843 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4, ptr + 8 + 8 + 4, checksumSize,
844 "magma_decoder_context_t::decode, OP_magma_semaphore_export: GL checksumCalculator failure\n");
845 }
846 size_t totalTmpSize = size_semaphore_handle_out;
847 totalTmpSize += sizeof(magma_status_t);
848 totalTmpSize += checksumSize;
849 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
850 OutputBuffer outptr_semaphore_handle_out(&tmpBuf[0], size_semaphore_handle_out);
851 DECODER_DEBUG_LOG("magma(%p): magma_semaphore_export(semaphore:%lu semaphore_handle_out:%p(%u) )", stream, var_semaphore, (magma_handle_t*)(outptr_semaphore_handle_out.get()), size_semaphore_handle_out);
852 *(magma_status_t *)(&tmpBuf[0 + size_semaphore_handle_out]) = this->magma_semaphore_export(var_semaphore, (magma_handle_t*)(outptr_semaphore_handle_out.get()));
853 outptr_semaphore_handle_out.flush();
854 if (useChecksum) {
855 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
856 }
857 stream->flush();
858 SET_LASTCALL("magma_semaphore_export");
859 android::base::endTrace();
860 break;
861 }
862 case OP_magma_poll: {
863 android::base::beginTrace("magma_poll decode");
864 uint32_t size_items __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
865 InputBuffer inptr_items(ptr + 8 + 4, size_items);
866 uint32_t var_count = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + size_items);
867 uint64_t var_timeout_ns = Unpack<uint64_t,uint64_t>(ptr + 8 + 4 + size_items + 4);
868 if (useChecksum) {
869 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_items + 4 + 8, ptr + 8 + 4 + size_items + 4 + 8, checksumSize,
870 "magma_decoder_context_t::decode, OP_magma_poll: GL checksumCalculator failure\n");
871 }
872 size_t totalTmpSize = size_items;
873 totalTmpSize += sizeof(magma_status_t);
874 totalTmpSize += checksumSize;
875 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
876 OutputBuffer outptr_items(&tmpBuf[0], size_items);
877 memcpy(outptr_items.get(), inptr_items.get(), size_items);
878 DECODER_DEBUG_LOG("magma(%p): magma_poll(items:%p(%u) count:%u timeout_ns:%lu )", stream, (magma_poll_item_t*)(outptr_items.get()), size_items, var_count, var_timeout_ns);
879 *(magma_status_t *)(&tmpBuf[0 + size_items]) = this->magma_poll((magma_poll_item_t*)(outptr_items.get()), var_count, var_timeout_ns);
880 outptr_items.flush();
881 if (useChecksum) {
882 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
883 }
884 stream->flush();
885 SET_LASTCALL("magma_poll");
886 android::base::endTrace();
887 break;
888 }
889 case OP_magma_initialize_tracing: {
890 android::base::beginTrace("magma_initialize_tracing decode");
891 magma_handle_t var_channel = Unpack<magma_handle_t,uint32_t>(ptr + 8);
892 if (useChecksum) {
893 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
894 "magma_decoder_context_t::decode, OP_magma_initialize_tracing: GL checksumCalculator failure\n");
895 }
896 size_t totalTmpSize = sizeof(magma_status_t);
897 totalTmpSize += checksumSize;
898 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
899 DECODER_DEBUG_LOG("magma(%p): magma_initialize_tracing(channel:%u )", stream, var_channel);
900 *(magma_status_t *)(&tmpBuf[0]) = this->magma_initialize_tracing(var_channel);
901 if (useChecksum) {
902 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
903 }
904 stream->flush();
905 SET_LASTCALL("magma_initialize_tracing");
906 android::base::endTrace();
907 break;
908 }
909 case OP_magma_initialize_logging: {
910 android::base::beginTrace("magma_initialize_logging decode");
911 magma_handle_t var_channel = Unpack<magma_handle_t,uint32_t>(ptr + 8);
912 if (useChecksum) {
913 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
914 "magma_decoder_context_t::decode, OP_magma_initialize_logging: GL checksumCalculator failure\n");
915 }
916 size_t totalTmpSize = sizeof(magma_status_t);
917 totalTmpSize += checksumSize;
918 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
919 DECODER_DEBUG_LOG("magma(%p): magma_initialize_logging(channel:%u )", stream, var_channel);
920 *(magma_status_t *)(&tmpBuf[0]) = this->magma_initialize_logging(var_channel);
921 if (useChecksum) {
922 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
923 }
924 stream->flush();
925 SET_LASTCALL("magma_initialize_logging");
926 android::base::endTrace();
927 break;
928 }
929 case OP_magma_connection_enable_performance_counter_access: {
930 android::base::beginTrace("magma_connection_enable_performance_counter_access decode");
931 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
932 magma_handle_t var_channel = Unpack<magma_handle_t,uint32_t>(ptr + 8 + 8);
933 if (useChecksum) {
934 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4, ptr + 8 + 8 + 4, checksumSize,
935 "magma_decoder_context_t::decode, OP_magma_connection_enable_performance_counter_access: GL checksumCalculator failure\n");
936 }
937 size_t totalTmpSize = sizeof(magma_status_t);
938 totalTmpSize += checksumSize;
939 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
940 DECODER_DEBUG_LOG("magma(%p): magma_connection_enable_performance_counter_access(connection:%lu channel:%u )", stream, var_connection, var_channel);
941 *(magma_status_t *)(&tmpBuf[0]) = this->magma_connection_enable_performance_counter_access(var_connection, var_channel);
942 if (useChecksum) {
943 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
944 }
945 stream->flush();
946 SET_LASTCALL("magma_connection_enable_performance_counter_access");
947 android::base::endTrace();
948 break;
949 }
950 case OP_magma_connection_enable_performance_counters: {
951 android::base::beginTrace("magma_connection_enable_performance_counters decode");
952 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
953 uint32_t size_counters __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
954 InputBuffer inptr_counters(ptr + 8 + 8 + 4, size_counters);
955 uint64_t var_counters_count = Unpack<uint64_t,uint64_t>(ptr + 8 + 8 + 4 + size_counters);
956 if (useChecksum) {
957 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + size_counters + 8, ptr + 8 + 8 + 4 + size_counters + 8, checksumSize,
958 "magma_decoder_context_t::decode, OP_magma_connection_enable_performance_counters: GL checksumCalculator failure\n");
959 }
960 size_t totalTmpSize = sizeof(magma_status_t);
961 totalTmpSize += checksumSize;
962 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
963 DECODER_DEBUG_LOG("magma(%p): magma_connection_enable_performance_counters(connection:%lu counters:%p(%u) counters_count:%lu )", stream, var_connection, (uint64_t*)(inptr_counters.get()), size_counters, var_counters_count);
964 *(magma_status_t *)(&tmpBuf[0]) = this->magma_connection_enable_performance_counters(var_connection, (uint64_t*)(inptr_counters.get()), var_counters_count);
965 if (useChecksum) {
966 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
967 }
968 stream->flush();
969 SET_LASTCALL("magma_connection_enable_performance_counters");
970 android::base::endTrace();
971 break;
972 }
973 case OP_magma_connection_create_performance_counter_buffer_pool: {
974 android::base::beginTrace("magma_connection_create_performance_counter_buffer_pool decode");
975 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
976 uint32_t size_pool_id_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
977 uint32_t size_notification_handle_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 4);
978 if (useChecksum) {
979 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + 4, ptr + 8 + 8 + 4 + 4, checksumSize,
980 "magma_decoder_context_t::decode, OP_magma_connection_create_performance_counter_buffer_pool: GL checksumCalculator failure\n");
981 }
982 size_t totalTmpSize = size_pool_id_out;
983 totalTmpSize += size_notification_handle_out;
984 totalTmpSize += sizeof(magma_status_t);
985 totalTmpSize += checksumSize;
986 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
987 OutputBuffer outptr_pool_id_out(&tmpBuf[0], size_pool_id_out);
988 OutputBuffer outptr_notification_handle_out(&tmpBuf[0 + size_pool_id_out], size_notification_handle_out);
989 DECODER_DEBUG_LOG("magma(%p): magma_connection_create_performance_counter_buffer_pool(connection:%lu pool_id_out:%p(%u) notification_handle_out:%p(%u) )", stream, var_connection, (magma_perf_count_pool_t*)(outptr_pool_id_out.get()), size_pool_id_out, (magma_handle_t*)(outptr_notification_handle_out.get()), size_notification_handle_out);
990 *(magma_status_t *)(&tmpBuf[0 + size_pool_id_out + size_notification_handle_out]) = this->magma_connection_create_performance_counter_buffer_pool(var_connection, (magma_perf_count_pool_t*)(outptr_pool_id_out.get()), (magma_handle_t*)(outptr_notification_handle_out.get()));
991 outptr_pool_id_out.flush();
992 outptr_notification_handle_out.flush();
993 if (useChecksum) {
994 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
995 }
996 stream->flush();
997 SET_LASTCALL("magma_connection_create_performance_counter_buffer_pool");
998 android::base::endTrace();
999 break;
1000 }
1001 case OP_magma_connection_release_performance_counter_buffer_pool: {
1002 android::base::beginTrace("magma_connection_release_performance_counter_buffer_pool decode");
1003 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
1004 magma_perf_count_pool_t var_pool_id = Unpack<magma_perf_count_pool_t,uint64_t>(ptr + 8 + 8);
1005 if (useChecksum) {
1006 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 8, ptr + 8 + 8 + 8, checksumSize,
1007 "magma_decoder_context_t::decode, OP_magma_connection_release_performance_counter_buffer_pool: GL checksumCalculator failure\n");
1008 }
1009 size_t totalTmpSize = sizeof(magma_status_t);
1010 totalTmpSize += checksumSize;
1011 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1012 DECODER_DEBUG_LOG("magma(%p): magma_connection_release_performance_counter_buffer_pool(connection:%lu pool_id:%lu )", stream, var_connection, var_pool_id);
1013 *(magma_status_t *)(&tmpBuf[0]) = this->magma_connection_release_performance_counter_buffer_pool(var_connection, var_pool_id);
1014 if (useChecksum) {
1015 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1016 }
1017 stream->flush();
1018 SET_LASTCALL("magma_connection_release_performance_counter_buffer_pool");
1019 android::base::endTrace();
1020 break;
1021 }
1022 case OP_magma_connection_add_performance_counter_buffer_offsets_to_pool: {
1023 android::base::beginTrace("magma_connection_add_performance_counter_buffer_offsets_to_pool decode");
1024 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
1025 magma_perf_count_pool_t var_pool_id = Unpack<magma_perf_count_pool_t,uint64_t>(ptr + 8 + 8);
1026 uint32_t size_offsets __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 8);
1027 InputBuffer inptr_offsets(ptr + 8 + 8 + 8 + 4, size_offsets);
1028 uint64_t var_offsets_count = Unpack<uint64_t,uint64_t>(ptr + 8 + 8 + 8 + 4 + size_offsets);
1029 if (useChecksum) {
1030 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 8 + 4 + size_offsets + 8, ptr + 8 + 8 + 8 + 4 + size_offsets + 8, checksumSize,
1031 "magma_decoder_context_t::decode, OP_magma_connection_add_performance_counter_buffer_offsets_to_pool: GL checksumCalculator failure\n");
1032 }
1033 size_t totalTmpSize = sizeof(magma_status_t);
1034 totalTmpSize += checksumSize;
1035 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1036 DECODER_DEBUG_LOG("magma(%p): magma_connection_add_performance_counter_buffer_offsets_to_pool(connection:%lu pool_id:%lu offsets:%p(%u) offsets_count:%lu )", stream, var_connection, var_pool_id, (const magma_buffer_offset_t*)(inptr_offsets.get()), size_offsets, var_offsets_count);
1037 *(magma_status_t *)(&tmpBuf[0]) = this->magma_connection_add_performance_counter_buffer_offsets_to_pool(var_connection, var_pool_id, (const magma_buffer_offset_t*)(inptr_offsets.get()), var_offsets_count);
1038 if (useChecksum) {
1039 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1040 }
1041 stream->flush();
1042 SET_LASTCALL("magma_connection_add_performance_counter_buffer_offsets_to_pool");
1043 android::base::endTrace();
1044 break;
1045 }
1046 case OP_magma_connection_remove_performance_counter_buffer_from_pool: {
1047 android::base::beginTrace("magma_connection_remove_performance_counter_buffer_from_pool decode");
1048 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
1049 magma_perf_count_pool_t var_pool_id = Unpack<magma_perf_count_pool_t,uint64_t>(ptr + 8 + 8);
1050 magma_buffer_t var_buffer = Unpack<magma_buffer_t,uint64_t>(ptr + 8 + 8 + 8);
1051 if (useChecksum) {
1052 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 8 + 8, ptr + 8 + 8 + 8 + 8, checksumSize,
1053 "magma_decoder_context_t::decode, OP_magma_connection_remove_performance_counter_buffer_from_pool: GL checksumCalculator failure\n");
1054 }
1055 size_t totalTmpSize = sizeof(magma_status_t);
1056 totalTmpSize += checksumSize;
1057 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1058 DECODER_DEBUG_LOG("magma(%p): magma_connection_remove_performance_counter_buffer_from_pool(connection:%lu pool_id:%lu buffer:%lu )", stream, var_connection, var_pool_id, var_buffer);
1059 *(magma_status_t *)(&tmpBuf[0]) = this->magma_connection_remove_performance_counter_buffer_from_pool(var_connection, var_pool_id, var_buffer);
1060 if (useChecksum) {
1061 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1062 }
1063 stream->flush();
1064 SET_LASTCALL("magma_connection_remove_performance_counter_buffer_from_pool");
1065 android::base::endTrace();
1066 break;
1067 }
1068 case OP_magma_connection_dump_performance_counters: {
1069 android::base::beginTrace("magma_connection_dump_performance_counters decode");
1070 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
1071 magma_perf_count_pool_t var_pool_id = Unpack<magma_perf_count_pool_t,uint64_t>(ptr + 8 + 8);
1072 uint32_t var_trigger_id = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 8);
1073 if (useChecksum) {
1074 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 8 + 4, ptr + 8 + 8 + 8 + 4, checksumSize,
1075 "magma_decoder_context_t::decode, OP_magma_connection_dump_performance_counters: GL checksumCalculator failure\n");
1076 }
1077 size_t totalTmpSize = sizeof(magma_status_t);
1078 totalTmpSize += checksumSize;
1079 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1080 DECODER_DEBUG_LOG("magma(%p): magma_connection_dump_performance_counters(connection:%lu pool_id:%lu trigger_id:%u )", stream, var_connection, var_pool_id, var_trigger_id);
1081 *(magma_status_t *)(&tmpBuf[0]) = this->magma_connection_dump_performance_counters(var_connection, var_pool_id, var_trigger_id);
1082 if (useChecksum) {
1083 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1084 }
1085 stream->flush();
1086 SET_LASTCALL("magma_connection_dump_performance_counters");
1087 android::base::endTrace();
1088 break;
1089 }
1090 case OP_magma_connection_clear_performance_counters: {
1091 android::base::beginTrace("magma_connection_clear_performance_counters decode");
1092 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
1093 uint32_t size_counters __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
1094 InputBuffer inptr_counters(ptr + 8 + 8 + 4, size_counters);
1095 uint64_t var_counters_count = Unpack<uint64_t,uint64_t>(ptr + 8 + 8 + 4 + size_counters);
1096 if (useChecksum) {
1097 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + size_counters + 8, ptr + 8 + 8 + 4 + size_counters + 8, checksumSize,
1098 "magma_decoder_context_t::decode, OP_magma_connection_clear_performance_counters: GL checksumCalculator failure\n");
1099 }
1100 size_t totalTmpSize = sizeof(magma_status_t);
1101 totalTmpSize += checksumSize;
1102 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1103 DECODER_DEBUG_LOG("magma(%p): magma_connection_clear_performance_counters(connection:%lu counters:%p(%u) counters_count:%lu )", stream, var_connection, (uint64_t*)(inptr_counters.get()), size_counters, var_counters_count);
1104 *(magma_status_t *)(&tmpBuf[0]) = this->magma_connection_clear_performance_counters(var_connection, (uint64_t*)(inptr_counters.get()), var_counters_count);
1105 if (useChecksum) {
1106 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1107 }
1108 stream->flush();
1109 SET_LASTCALL("magma_connection_clear_performance_counters");
1110 android::base::endTrace();
1111 break;
1112 }
1113 case OP_magma_connection_read_performance_counter_completion: {
1114 android::base::beginTrace("magma_connection_read_performance_counter_completion decode");
1115 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
1116 magma_perf_count_pool_t var_pool_id = Unpack<magma_perf_count_pool_t,uint64_t>(ptr + 8 + 8);
1117 uint32_t size_trigger_id_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 8);
1118 uint32_t size_buffer_id_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 8 + 4);
1119 uint32_t size_buffer_offset_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 8 + 4 + 4);
1120 uint32_t size_time_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 8 + 4 + 4 + 4);
1121 uint32_t size_result_flags_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 8 + 4 + 4 + 4 + 4);
1122 if (useChecksum) {
1123 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 8 + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
1124 "magma_decoder_context_t::decode, OP_magma_connection_read_performance_counter_completion: GL checksumCalculator failure\n");
1125 }
1126 size_t totalTmpSize = size_trigger_id_out;
1127 totalTmpSize += size_buffer_id_out;
1128 totalTmpSize += size_buffer_offset_out;
1129 totalTmpSize += size_time_out;
1130 totalTmpSize += size_result_flags_out;
1131 totalTmpSize += sizeof(magma_status_t);
1132 totalTmpSize += checksumSize;
1133 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1134 OutputBuffer outptr_trigger_id_out(&tmpBuf[0], size_trigger_id_out);
1135 OutputBuffer outptr_buffer_id_out(&tmpBuf[0 + size_trigger_id_out], size_buffer_id_out);
1136 OutputBuffer outptr_buffer_offset_out(&tmpBuf[0 + size_trigger_id_out + size_buffer_id_out], size_buffer_offset_out);
1137 OutputBuffer outptr_time_out(&tmpBuf[0 + size_trigger_id_out + size_buffer_id_out + size_buffer_offset_out], size_time_out);
1138 OutputBuffer outptr_result_flags_out(&tmpBuf[0 + size_trigger_id_out + size_buffer_id_out + size_buffer_offset_out + size_time_out], size_result_flags_out);
1139 DECODER_DEBUG_LOG("magma(%p): magma_connection_read_performance_counter_completion(connection:%lu pool_id:%lu trigger_id_out:%p(%u) buffer_id_out:%p(%u) buffer_offset_out:%p(%u) time_out:%p(%u) result_flags_out:%p(%u) )", stream, var_connection, var_pool_id, (uint32_t*)(outptr_trigger_id_out.get()), size_trigger_id_out, (uint64_t*)(outptr_buffer_id_out.get()), size_buffer_id_out, (uint32_t*)(outptr_buffer_offset_out.get()), size_buffer_offset_out, (uint64_t*)(outptr_time_out.get()), size_time_out, (uint32_t*)(outptr_result_flags_out.get()), size_result_flags_out);
1140 *(magma_status_t *)(&tmpBuf[0 + size_trigger_id_out + size_buffer_id_out + size_buffer_offset_out + size_time_out + size_result_flags_out]) = this->magma_connection_read_performance_counter_completion(var_connection, var_pool_id, (uint32_t*)(outptr_trigger_id_out.get()), (uint64_t*)(outptr_buffer_id_out.get()), (uint32_t*)(outptr_buffer_offset_out.get()), (uint64_t*)(outptr_time_out.get()), (uint32_t*)(outptr_result_flags_out.get()));
1141 outptr_trigger_id_out.flush();
1142 outptr_buffer_id_out.flush();
1143 outptr_buffer_offset_out.flush();
1144 outptr_time_out.flush();
1145 outptr_result_flags_out.flush();
1146 if (useChecksum) {
1147 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1148 }
1149 stream->flush();
1150 SET_LASTCALL("magma_connection_read_performance_counter_completion");
1151 android::base::endTrace();
1152 break;
1153 }
1154 case OP_magma_virt_connection_create_image: {
1155 android::base::beginTrace("magma_virt_connection_create_image decode");
1156 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
1157 uint32_t size_create_info __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8);
1158 InputBuffer inptr_create_info(ptr + 8 + 8 + 4, size_create_info);
1159 uint32_t size_size_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 4 + size_create_info);
1160 uint32_t size_image_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 4 + size_create_info + 4);
1161 uint32_t size_buffer_id_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 4 + size_create_info + 4 + 4);
1162 if (useChecksum) {
1163 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 4 + size_create_info + 4 + 4 + 4, ptr + 8 + 8 + 4 + size_create_info + 4 + 4 + 4, checksumSize,
1164 "magma_decoder_context_t::decode, OP_magma_virt_connection_create_image: GL checksumCalculator failure\n");
1165 }
1166 size_t totalTmpSize = size_size_out;
1167 totalTmpSize += size_image_out;
1168 totalTmpSize += size_buffer_id_out;
1169 totalTmpSize += sizeof(magma_status_t);
1170 totalTmpSize += checksumSize;
1171 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1172 OutputBuffer outptr_size_out(&tmpBuf[0], size_size_out);
1173 OutputBuffer outptr_image_out(&tmpBuf[0 + size_size_out], size_image_out);
1174 OutputBuffer outptr_buffer_id_out(&tmpBuf[0 + size_size_out + size_image_out], size_buffer_id_out);
1175 DECODER_DEBUG_LOG("magma(%p): magma_virt_connection_create_image(connection:%lu create_info:%p(%u) size_out:%p(%u) image_out:%p(%u) buffer_id_out:%p(%u) )", stream, var_connection, (magma_image_create_info_t*)(inptr_create_info.get()), size_create_info, (uint64_t*)(outptr_size_out.get()), size_size_out, (magma_buffer_t*)(outptr_image_out.get()), size_image_out, (magma_buffer_id_t*)(outptr_buffer_id_out.get()), size_buffer_id_out);
1176 *(magma_status_t *)(&tmpBuf[0 + size_size_out + size_image_out + size_buffer_id_out]) = this->magma_virt_connection_create_image(var_connection, (magma_image_create_info_t*)(inptr_create_info.get()), (uint64_t*)(outptr_size_out.get()), (magma_buffer_t*)(outptr_image_out.get()), (magma_buffer_id_t*)(outptr_buffer_id_out.get()));
1177 outptr_size_out.flush();
1178 outptr_image_out.flush();
1179 outptr_buffer_id_out.flush();
1180 if (useChecksum) {
1181 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1182 }
1183 stream->flush();
1184 SET_LASTCALL("magma_virt_connection_create_image");
1185 android::base::endTrace();
1186 break;
1187 }
1188 case OP_magma_virt_connection_get_image_info: {
1189 android::base::beginTrace("magma_virt_connection_get_image_info decode");
1190 magma_connection_t var_connection = Unpack<magma_connection_t,uint64_t>(ptr + 8);
1191 magma_buffer_t var_image = Unpack<magma_buffer_t,uint64_t>(ptr + 8 + 8);
1192 uint32_t size_image_info_out __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 8 + 8);
1193 if (useChecksum) {
1194 ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 8 + 8 + 4, ptr + 8 + 8 + 8 + 4, checksumSize,
1195 "magma_decoder_context_t::decode, OP_magma_virt_connection_get_image_info: GL checksumCalculator failure\n");
1196 }
1197 size_t totalTmpSize = size_image_info_out;
1198 totalTmpSize += sizeof(magma_status_t);
1199 totalTmpSize += checksumSize;
1200 unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1201 OutputBuffer outptr_image_info_out(&tmpBuf[0], size_image_info_out);
1202 DECODER_DEBUG_LOG("magma(%p): magma_virt_connection_get_image_info(connection:%lu image:%lu image_info_out:%p(%u) )", stream, var_connection, var_image, (magma_image_info_t*)(outptr_image_info_out.get()), size_image_info_out);
1203 *(magma_status_t *)(&tmpBuf[0 + size_image_info_out]) = this->magma_virt_connection_get_image_info(var_connection, var_image, (magma_image_info_t*)(outptr_image_info_out.get()));
1204 outptr_image_info_out.flush();
1205 if (useChecksum) {
1206 ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1207 }
1208 stream->flush();
1209 SET_LASTCALL("magma_virt_connection_get_image_info");
1210 android::base::endTrace();
1211 break;
1212 }
1213 default:
1214 return ptr - (unsigned char*)buf;
1215 } //switch
1216 ptr += packetLen;
1217 } // while
1218 return ptr - (unsigned char*)buf;
1219 }
1220 } // namespace gfxstream
1221
1222