1 // Generated Code - DO NOT EDIT !!
2 // generated by 'emugen'
3
4
5 #include <string.h>
6 #include "renderControl_opcodes.h"
7
8 #include "renderControl_enc.h"
9
10
11 #include <vector>
12
13 #include <stdio.h>
14
15 #include "aemu/base/Tracing.h"
16
17 #include "EncoderDebug.h"
18
19 using gfxstream::guest::ChecksumCalculator;
20
21 using gfxstream::guest::IOStream;
22
23 namespace {
24
enc_unsupported()25 void enc_unsupported()
26 {
27 ALOGE("Function is unsupported\n");
28 }
29
rcGetRendererVersion_enc(void * self)30 GLint rcGetRendererVersion_enc(void *self )
31 {
32 ENCODER_DEBUG_LOG("rcGetRendererVersion()");
33 AEMU_SCOPED_TRACE("rcGetRendererVersion encode");
34
35 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
36 IOStream *stream = ctx->m_stream;
37 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
38 bool useChecksum = checksumCalculator->getVersion() > 0;
39
40 unsigned char *ptr;
41 unsigned char *buf;
42 const size_t sizeWithoutChecksum = 8;
43 const size_t checksumSize = checksumCalculator->checksumByteSize();
44 const size_t totalSize = sizeWithoutChecksum + checksumSize;
45 buf = stream->alloc(totalSize);
46 ptr = buf;
47 int tmp = OP_rcGetRendererVersion;memcpy(ptr, &tmp, 4); ptr += 4;
48 memcpy(ptr, &totalSize, 4); ptr += 4;
49
50
51 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
52 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
53
54
55 GLint retval;
56 stream->readback(&retval, 4);
57 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
58 if (useChecksum) {
59 unsigned char *checksumBufPtr = NULL;
60 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
61 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
62 stream->readback(checksumBufPtr, checksumSize);
63 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
64 ALOGE("rcGetRendererVersion: GL communication error, please report this issue to b.android.com.\n");
65 abort();
66 }
67 }
68 return retval;
69 }
70
rcGetEGLVersion_enc(void * self,EGLint * major,EGLint * minor)71 EGLint rcGetEGLVersion_enc(void *self , EGLint* major, EGLint* minor)
72 {
73 ENCODER_DEBUG_LOG("rcGetEGLVersion(major:0x%08x, minor:0x%08x)", major, minor);
74 AEMU_SCOPED_TRACE("rcGetEGLVersion encode");
75
76 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
77 IOStream *stream = ctx->m_stream;
78 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
79 bool useChecksum = checksumCalculator->getVersion() > 0;
80
81 const unsigned int __size_major = sizeof(EGLint);
82 const unsigned int __size_minor = sizeof(EGLint);
83 unsigned char *ptr;
84 unsigned char *buf;
85 const size_t sizeWithoutChecksum = 8 + 0 + 0 + 2*4;
86 const size_t checksumSize = checksumCalculator->checksumByteSize();
87 const size_t totalSize = sizeWithoutChecksum + checksumSize;
88 buf = stream->alloc(totalSize);
89 ptr = buf;
90 int tmp = OP_rcGetEGLVersion;memcpy(ptr, &tmp, 4); ptr += 4;
91 memcpy(ptr, &totalSize, 4); ptr += 4;
92
93 memcpy(ptr, &__size_major, 4); ptr += 4;
94 memcpy(ptr, &__size_minor, 4); ptr += 4;
95
96 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
97 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
98
99 stream->readback(major, __size_major);
100 if (useChecksum) checksumCalculator->addBuffer(major, __size_major);
101 stream->readback(minor, __size_minor);
102 if (useChecksum) checksumCalculator->addBuffer(minor, __size_minor);
103
104 EGLint retval;
105 stream->readback(&retval, 4);
106 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
107 if (useChecksum) {
108 unsigned char *checksumBufPtr = NULL;
109 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
110 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
111 stream->readback(checksumBufPtr, checksumSize);
112 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
113 ALOGE("rcGetEGLVersion: GL communication error, please report this issue to b.android.com.\n");
114 abort();
115 }
116 }
117 return retval;
118 }
119
rcQueryEGLString_enc(void * self,EGLenum name,void * buffer,EGLint bufferSize)120 EGLint rcQueryEGLString_enc(void *self , EGLenum name, void* buffer, EGLint bufferSize)
121 {
122 ENCODER_DEBUG_LOG("rcQueryEGLString(name:0x%08x, buffer:0x%08x, bufferSize:0x%08x)", name, buffer, bufferSize);
123 AEMU_SCOPED_TRACE("rcQueryEGLString encode");
124
125 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
126 IOStream *stream = ctx->m_stream;
127 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
128 bool useChecksum = checksumCalculator->getVersion() > 0;
129
130 const unsigned int __size_buffer = bufferSize;
131 unsigned char *ptr;
132 unsigned char *buf;
133 const size_t sizeWithoutChecksum = 8 + 4 + 0 + 4 + 1*4;
134 const size_t checksumSize = checksumCalculator->checksumByteSize();
135 const size_t totalSize = sizeWithoutChecksum + checksumSize;
136 buf = stream->alloc(totalSize);
137 ptr = buf;
138 int tmp = OP_rcQueryEGLString;memcpy(ptr, &tmp, 4); ptr += 4;
139 memcpy(ptr, &totalSize, 4); ptr += 4;
140
141 memcpy(ptr, &name, 4); ptr += 4;
142 memcpy(ptr, &__size_buffer, 4); ptr += 4;
143 memcpy(ptr, &bufferSize, 4); ptr += 4;
144
145 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
146 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
147
148 stream->readback(buffer, __size_buffer);
149 if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer);
150
151 EGLint retval;
152 stream->readback(&retval, 4);
153 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
154 if (useChecksum) {
155 unsigned char *checksumBufPtr = NULL;
156 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
157 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
158 stream->readback(checksumBufPtr, checksumSize);
159 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
160 ALOGE("rcQueryEGLString: GL communication error, please report this issue to b.android.com.\n");
161 abort();
162 }
163 }
164 return retval;
165 }
166
rcGetGLString_enc(void * self,EGLenum name,void * buffer,EGLint bufferSize)167 EGLint rcGetGLString_enc(void *self , EGLenum name, void* buffer, EGLint bufferSize)
168 {
169 ENCODER_DEBUG_LOG("rcGetGLString(name:0x%08x, buffer:0x%08x, bufferSize:0x%08x)", name, buffer, bufferSize);
170 AEMU_SCOPED_TRACE("rcGetGLString encode");
171
172 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
173 IOStream *stream = ctx->m_stream;
174 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
175 bool useChecksum = checksumCalculator->getVersion() > 0;
176
177 const unsigned int __size_buffer = bufferSize;
178 unsigned char *ptr;
179 unsigned char *buf;
180 const size_t sizeWithoutChecksum = 8 + 4 + 0 + 4 + 1*4;
181 const size_t checksumSize = checksumCalculator->checksumByteSize();
182 const size_t totalSize = sizeWithoutChecksum + checksumSize;
183 buf = stream->alloc(totalSize);
184 ptr = buf;
185 int tmp = OP_rcGetGLString;memcpy(ptr, &tmp, 4); ptr += 4;
186 memcpy(ptr, &totalSize, 4); ptr += 4;
187
188 memcpy(ptr, &name, 4); ptr += 4;
189 memcpy(ptr, &__size_buffer, 4); ptr += 4;
190 memcpy(ptr, &bufferSize, 4); ptr += 4;
191
192 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
193 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
194
195 stream->readback(buffer, __size_buffer);
196 if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer);
197
198 EGLint retval;
199 stream->readback(&retval, 4);
200 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
201 if (useChecksum) {
202 unsigned char *checksumBufPtr = NULL;
203 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
204 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
205 stream->readback(checksumBufPtr, checksumSize);
206 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
207 ALOGE("rcGetGLString: GL communication error, please report this issue to b.android.com.\n");
208 abort();
209 }
210 }
211 return retval;
212 }
213
rcGetNumConfigs_enc(void * self,uint32_t * numAttribs)214 EGLint rcGetNumConfigs_enc(void *self , uint32_t* numAttribs)
215 {
216 ENCODER_DEBUG_LOG("rcGetNumConfigs(numAttribs:0x%08x)", numAttribs);
217 AEMU_SCOPED_TRACE("rcGetNumConfigs encode");
218
219 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
220 IOStream *stream = ctx->m_stream;
221 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
222 bool useChecksum = checksumCalculator->getVersion() > 0;
223
224 const unsigned int __size_numAttribs = sizeof(uint32_t);
225 unsigned char *ptr;
226 unsigned char *buf;
227 const size_t sizeWithoutChecksum = 8 + 0 + 1*4;
228 const size_t checksumSize = checksumCalculator->checksumByteSize();
229 const size_t totalSize = sizeWithoutChecksum + checksumSize;
230 buf = stream->alloc(totalSize);
231 ptr = buf;
232 int tmp = OP_rcGetNumConfigs;memcpy(ptr, &tmp, 4); ptr += 4;
233 memcpy(ptr, &totalSize, 4); ptr += 4;
234
235 memcpy(ptr, &__size_numAttribs, 4); ptr += 4;
236
237 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
238 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
239
240 stream->readback(numAttribs, __size_numAttribs);
241 if (useChecksum) checksumCalculator->addBuffer(numAttribs, __size_numAttribs);
242
243 EGLint retval;
244 stream->readback(&retval, 4);
245 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
246 if (useChecksum) {
247 unsigned char *checksumBufPtr = NULL;
248 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
249 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
250 stream->readback(checksumBufPtr, checksumSize);
251 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
252 ALOGE("rcGetNumConfigs: GL communication error, please report this issue to b.android.com.\n");
253 abort();
254 }
255 }
256 return retval;
257 }
258
rcGetConfigs_enc(void * self,uint32_t bufSize,GLuint * buffer)259 EGLint rcGetConfigs_enc(void *self , uint32_t bufSize, GLuint* buffer)
260 {
261 ENCODER_DEBUG_LOG("rcGetConfigs(bufSize:0x%08x, buffer:0x%08x)", bufSize, buffer);
262 AEMU_SCOPED_TRACE("rcGetConfigs encode");
263
264 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
265 IOStream *stream = ctx->m_stream;
266 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
267 bool useChecksum = checksumCalculator->getVersion() > 0;
268
269 const unsigned int __size_buffer = bufSize;
270 unsigned char *ptr;
271 unsigned char *buf;
272 const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
273 const size_t checksumSize = checksumCalculator->checksumByteSize();
274 const size_t totalSize = sizeWithoutChecksum + checksumSize;
275 buf = stream->alloc(totalSize);
276 ptr = buf;
277 int tmp = OP_rcGetConfigs;memcpy(ptr, &tmp, 4); ptr += 4;
278 memcpy(ptr, &totalSize, 4); ptr += 4;
279
280 memcpy(ptr, &bufSize, 4); ptr += 4;
281 memcpy(ptr, &__size_buffer, 4); ptr += 4;
282
283 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
284 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
285
286 stream->readback(buffer, __size_buffer);
287 if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer);
288
289 EGLint retval;
290 stream->readback(&retval, 4);
291 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
292 if (useChecksum) {
293 unsigned char *checksumBufPtr = NULL;
294 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
295 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
296 stream->readback(checksumBufPtr, checksumSize);
297 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
298 ALOGE("rcGetConfigs: GL communication error, please report this issue to b.android.com.\n");
299 abort();
300 }
301 }
302 return retval;
303 }
304
rcChooseConfig_enc(void * self,EGLint * attribs,uint32_t attribs_size,uint32_t * configs,uint32_t configs_size)305 EGLint rcChooseConfig_enc(void *self , EGLint* attribs, uint32_t attribs_size, uint32_t* configs, uint32_t configs_size)
306 {
307 ENCODER_DEBUG_LOG("rcChooseConfig(attribs:0x%08x, attribs_size:0x%08x, configs:0x%08x, configs_size:0x%08x)", attribs, attribs_size, configs, configs_size);
308 AEMU_SCOPED_TRACE("rcChooseConfig encode");
309
310 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
311 IOStream *stream = ctx->m_stream;
312 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
313 bool useChecksum = checksumCalculator->getVersion() > 0;
314
315 const unsigned int __size_attribs = attribs_size;
316 const unsigned int __size_configs = ((configs != NULL) ? configs_size*sizeof(uint32_t) : 0);
317 unsigned char *ptr;
318 unsigned char *buf;
319 const size_t sizeWithoutChecksum = 8 + __size_attribs + 4 + 0 + 4 + 2*4;
320 const size_t checksumSize = checksumCalculator->checksumByteSize();
321 const size_t totalSize = sizeWithoutChecksum + checksumSize;
322 buf = stream->alloc(totalSize);
323 ptr = buf;
324 int tmp = OP_rcChooseConfig;memcpy(ptr, &tmp, 4); ptr += 4;
325 memcpy(ptr, &totalSize, 4); ptr += 4;
326
327 memcpy(ptr, &__size_attribs, 4); ptr += 4;
328 memcpy(ptr, attribs, __size_attribs);ptr += __size_attribs;
329 memcpy(ptr, &attribs_size, 4); ptr += 4;
330 memcpy(ptr, &__size_configs, 4); ptr += 4;
331 memcpy(ptr, &configs_size, 4); ptr += 4;
332
333 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
334 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
335
336 if (configs != NULL) {
337 stream->readback(configs, __size_configs);
338 if (useChecksum) checksumCalculator->addBuffer(configs, __size_configs);
339 }
340
341 EGLint retval;
342 stream->readback(&retval, 4);
343 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
344 if (useChecksum) {
345 unsigned char *checksumBufPtr = NULL;
346 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
347 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
348 stream->readback(checksumBufPtr, checksumSize);
349 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
350 ALOGE("rcChooseConfig: GL communication error, please report this issue to b.android.com.\n");
351 abort();
352 }
353 }
354 return retval;
355 }
356
rcGetFBParam_enc(void * self,EGLint param)357 EGLint rcGetFBParam_enc(void *self , EGLint param)
358 {
359 ENCODER_DEBUG_LOG("rcGetFBParam(param:0x%08x)", param);
360 AEMU_SCOPED_TRACE("rcGetFBParam encode");
361
362 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
363 IOStream *stream = ctx->m_stream;
364 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
365 bool useChecksum = checksumCalculator->getVersion() > 0;
366
367 unsigned char *ptr;
368 unsigned char *buf;
369 const size_t sizeWithoutChecksum = 8 + 4;
370 const size_t checksumSize = checksumCalculator->checksumByteSize();
371 const size_t totalSize = sizeWithoutChecksum + checksumSize;
372 buf = stream->alloc(totalSize);
373 ptr = buf;
374 int tmp = OP_rcGetFBParam;memcpy(ptr, &tmp, 4); ptr += 4;
375 memcpy(ptr, &totalSize, 4); ptr += 4;
376
377 memcpy(ptr, ¶m, 4); ptr += 4;
378
379 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
380 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
381
382
383 EGLint retval;
384 stream->readback(&retval, 4);
385 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
386 if (useChecksum) {
387 unsigned char *checksumBufPtr = NULL;
388 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
389 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
390 stream->readback(checksumBufPtr, checksumSize);
391 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
392 ALOGE("rcGetFBParam: GL communication error, please report this issue to b.android.com.\n");
393 abort();
394 }
395 }
396 return retval;
397 }
398
rcCreateContext_enc(void * self,uint32_t config,uint32_t share,uint32_t glVersion)399 uint32_t rcCreateContext_enc(void *self , uint32_t config, uint32_t share, uint32_t glVersion)
400 {
401 ENCODER_DEBUG_LOG("rcCreateContext(config:0x%08x, share:0x%08x, glVersion:0x%08x)", config, share, glVersion);
402 AEMU_SCOPED_TRACE("rcCreateContext encode");
403
404 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
405 IOStream *stream = ctx->m_stream;
406 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
407 bool useChecksum = checksumCalculator->getVersion() > 0;
408
409 unsigned char *ptr;
410 unsigned char *buf;
411 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
412 const size_t checksumSize = checksumCalculator->checksumByteSize();
413 const size_t totalSize = sizeWithoutChecksum + checksumSize;
414 buf = stream->alloc(totalSize);
415 ptr = buf;
416 int tmp = OP_rcCreateContext;memcpy(ptr, &tmp, 4); ptr += 4;
417 memcpy(ptr, &totalSize, 4); ptr += 4;
418
419 memcpy(ptr, &config, 4); ptr += 4;
420 memcpy(ptr, &share, 4); ptr += 4;
421 memcpy(ptr, &glVersion, 4); ptr += 4;
422
423 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
424 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
425
426
427 uint32_t retval;
428 stream->readback(&retval, 4);
429 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
430 if (useChecksum) {
431 unsigned char *checksumBufPtr = NULL;
432 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
433 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
434 stream->readback(checksumBufPtr, checksumSize);
435 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
436 ALOGE("rcCreateContext: GL communication error, please report this issue to b.android.com.\n");
437 abort();
438 }
439 }
440 return retval;
441 }
442
rcDestroyContext_enc(void * self,uint32_t context)443 void rcDestroyContext_enc(void *self , uint32_t context)
444 {
445 ENCODER_DEBUG_LOG("rcDestroyContext(context:0x%08x)", context);
446 AEMU_SCOPED_TRACE("rcDestroyContext encode");
447
448 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
449 IOStream *stream = ctx->m_stream;
450 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
451 bool useChecksum = checksumCalculator->getVersion() > 0;
452
453 unsigned char *ptr;
454 unsigned char *buf;
455 const size_t sizeWithoutChecksum = 8 + 4;
456 const size_t checksumSize = checksumCalculator->checksumByteSize();
457 const size_t totalSize = sizeWithoutChecksum + checksumSize;
458 buf = stream->alloc(totalSize);
459 ptr = buf;
460 int tmp = OP_rcDestroyContext;memcpy(ptr, &tmp, 4); ptr += 4;
461 memcpy(ptr, &totalSize, 4); ptr += 4;
462
463 memcpy(ptr, &context, 4); ptr += 4;
464
465 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
466 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
467
468 }
469
rcCreateWindowSurface_enc(void * self,uint32_t config,uint32_t width,uint32_t height)470 uint32_t rcCreateWindowSurface_enc(void *self , uint32_t config, uint32_t width, uint32_t height)
471 {
472 ENCODER_DEBUG_LOG("rcCreateWindowSurface(config:0x%08x, width:0x%08x, height:0x%08x)", config, width, height);
473 AEMU_SCOPED_TRACE("rcCreateWindowSurface encode");
474
475 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
476 IOStream *stream = ctx->m_stream;
477 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
478 bool useChecksum = checksumCalculator->getVersion() > 0;
479
480 unsigned char *ptr;
481 unsigned char *buf;
482 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
483 const size_t checksumSize = checksumCalculator->checksumByteSize();
484 const size_t totalSize = sizeWithoutChecksum + checksumSize;
485 buf = stream->alloc(totalSize);
486 ptr = buf;
487 int tmp = OP_rcCreateWindowSurface;memcpy(ptr, &tmp, 4); ptr += 4;
488 memcpy(ptr, &totalSize, 4); ptr += 4;
489
490 memcpy(ptr, &config, 4); ptr += 4;
491 memcpy(ptr, &width, 4); ptr += 4;
492 memcpy(ptr, &height, 4); ptr += 4;
493
494 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
495 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
496
497
498 uint32_t retval;
499 stream->readback(&retval, 4);
500 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
501 if (useChecksum) {
502 unsigned char *checksumBufPtr = NULL;
503 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
504 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
505 stream->readback(checksumBufPtr, checksumSize);
506 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
507 ALOGE("rcCreateWindowSurface: GL communication error, please report this issue to b.android.com.\n");
508 abort();
509 }
510 }
511 return retval;
512 }
513
rcDestroyWindowSurface_enc(void * self,uint32_t windowSurface)514 void rcDestroyWindowSurface_enc(void *self , uint32_t windowSurface)
515 {
516 ENCODER_DEBUG_LOG("rcDestroyWindowSurface(windowSurface:0x%08x)", windowSurface);
517 AEMU_SCOPED_TRACE("rcDestroyWindowSurface encode");
518
519 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
520 IOStream *stream = ctx->m_stream;
521 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
522 bool useChecksum = checksumCalculator->getVersion() > 0;
523
524 unsigned char *ptr;
525 unsigned char *buf;
526 const size_t sizeWithoutChecksum = 8 + 4;
527 const size_t checksumSize = checksumCalculator->checksumByteSize();
528 const size_t totalSize = sizeWithoutChecksum + checksumSize;
529 buf = stream->alloc(totalSize);
530 ptr = buf;
531 int tmp = OP_rcDestroyWindowSurface;memcpy(ptr, &tmp, 4); ptr += 4;
532 memcpy(ptr, &totalSize, 4); ptr += 4;
533
534 memcpy(ptr, &windowSurface, 4); ptr += 4;
535
536 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
537 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
538
539 }
540
rcCreateColorBuffer_enc(void * self,uint32_t width,uint32_t height,GLenum internalFormat)541 uint32_t rcCreateColorBuffer_enc(void *self , uint32_t width, uint32_t height, GLenum internalFormat)
542 {
543 ENCODER_DEBUG_LOG("rcCreateColorBuffer(width:0x%08x, height:0x%08x, internalFormat:0x%08x)", width, height, internalFormat);
544 AEMU_SCOPED_TRACE("rcCreateColorBuffer encode");
545
546 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
547 IOStream *stream = ctx->m_stream;
548 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
549 bool useChecksum = checksumCalculator->getVersion() > 0;
550
551 unsigned char *ptr;
552 unsigned char *buf;
553 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
554 const size_t checksumSize = checksumCalculator->checksumByteSize();
555 const size_t totalSize = sizeWithoutChecksum + checksumSize;
556 buf = stream->alloc(totalSize);
557 ptr = buf;
558 int tmp = OP_rcCreateColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
559 memcpy(ptr, &totalSize, 4); ptr += 4;
560
561 memcpy(ptr, &width, 4); ptr += 4;
562 memcpy(ptr, &height, 4); ptr += 4;
563 memcpy(ptr, &internalFormat, 4); ptr += 4;
564
565 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
566 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
567
568
569 uint32_t retval;
570 stream->readback(&retval, 4);
571 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
572 if (useChecksum) {
573 unsigned char *checksumBufPtr = NULL;
574 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
575 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
576 stream->readback(checksumBufPtr, checksumSize);
577 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
578 ALOGE("rcCreateColorBuffer: GL communication error, please report this issue to b.android.com.\n");
579 abort();
580 }
581 }
582 return retval;
583 }
584
rcOpenColorBuffer_enc(void * self,uint32_t colorbuffer)585 void rcOpenColorBuffer_enc(void *self , uint32_t colorbuffer)
586 {
587 ENCODER_DEBUG_LOG("rcOpenColorBuffer(colorbuffer:0x%08x)", colorbuffer);
588 AEMU_SCOPED_TRACE("rcOpenColorBuffer encode");
589
590 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
591 IOStream *stream = ctx->m_stream;
592 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
593 bool useChecksum = checksumCalculator->getVersion() > 0;
594
595 unsigned char *ptr;
596 unsigned char *buf;
597 const size_t sizeWithoutChecksum = 8 + 4;
598 const size_t checksumSize = checksumCalculator->checksumByteSize();
599 const size_t totalSize = sizeWithoutChecksum + checksumSize;
600 buf = stream->alloc(totalSize);
601 ptr = buf;
602 int tmp = OP_rcOpenColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
603 memcpy(ptr, &totalSize, 4); ptr += 4;
604
605 memcpy(ptr, &colorbuffer, 4); ptr += 4;
606
607 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
608 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
609
610 }
611
rcCloseColorBuffer_enc(void * self,uint32_t colorbuffer)612 void rcCloseColorBuffer_enc(void *self , uint32_t colorbuffer)
613 {
614 ENCODER_DEBUG_LOG("rcCloseColorBuffer(colorbuffer:0x%08x)", colorbuffer);
615 AEMU_SCOPED_TRACE("rcCloseColorBuffer encode");
616
617 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
618 IOStream *stream = ctx->m_stream;
619 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
620 bool useChecksum = checksumCalculator->getVersion() > 0;
621
622 unsigned char *ptr;
623 unsigned char *buf;
624 const size_t sizeWithoutChecksum = 8 + 4;
625 const size_t checksumSize = checksumCalculator->checksumByteSize();
626 const size_t totalSize = sizeWithoutChecksum + checksumSize;
627 buf = stream->alloc(totalSize);
628 ptr = buf;
629 int tmp = OP_rcCloseColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
630 memcpy(ptr, &totalSize, 4); ptr += 4;
631
632 memcpy(ptr, &colorbuffer, 4); ptr += 4;
633
634 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
635 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
636
637 stream->flush();
638 }
639
rcSetWindowColorBuffer_enc(void * self,uint32_t windowSurface,uint32_t colorBuffer)640 void rcSetWindowColorBuffer_enc(void *self , uint32_t windowSurface, uint32_t colorBuffer)
641 {
642 ENCODER_DEBUG_LOG("rcSetWindowColorBuffer(windowSurface:0x%08x, colorBuffer:0x%08x)", windowSurface, colorBuffer);
643 AEMU_SCOPED_TRACE("rcSetWindowColorBuffer encode");
644
645 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
646 IOStream *stream = ctx->m_stream;
647 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
648 bool useChecksum = checksumCalculator->getVersion() > 0;
649
650 unsigned char *ptr;
651 unsigned char *buf;
652 const size_t sizeWithoutChecksum = 8 + 4 + 4;
653 const size_t checksumSize = checksumCalculator->checksumByteSize();
654 const size_t totalSize = sizeWithoutChecksum + checksumSize;
655 buf = stream->alloc(totalSize);
656 ptr = buf;
657 int tmp = OP_rcSetWindowColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
658 memcpy(ptr, &totalSize, 4); ptr += 4;
659
660 memcpy(ptr, &windowSurface, 4); ptr += 4;
661 memcpy(ptr, &colorBuffer, 4); ptr += 4;
662
663 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
664 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
665
666 }
667
rcFlushWindowColorBuffer_enc(void * self,uint32_t windowSurface)668 int rcFlushWindowColorBuffer_enc(void *self , uint32_t windowSurface)
669 {
670 ENCODER_DEBUG_LOG("rcFlushWindowColorBuffer(windowSurface:0x%08x)", windowSurface);
671 AEMU_SCOPED_TRACE("rcFlushWindowColorBuffer encode");
672
673 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
674 IOStream *stream = ctx->m_stream;
675 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
676 bool useChecksum = checksumCalculator->getVersion() > 0;
677
678 unsigned char *ptr;
679 unsigned char *buf;
680 const size_t sizeWithoutChecksum = 8 + 4;
681 const size_t checksumSize = checksumCalculator->checksumByteSize();
682 const size_t totalSize = sizeWithoutChecksum + checksumSize;
683 buf = stream->alloc(totalSize);
684 ptr = buf;
685 int tmp = OP_rcFlushWindowColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
686 memcpy(ptr, &totalSize, 4); ptr += 4;
687
688 memcpy(ptr, &windowSurface, 4); ptr += 4;
689
690 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
691 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
692
693
694 int retval;
695 stream->readback(&retval, 4);
696 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
697 if (useChecksum) {
698 unsigned char *checksumBufPtr = NULL;
699 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
700 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
701 stream->readback(checksumBufPtr, checksumSize);
702 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
703 ALOGE("rcFlushWindowColorBuffer: GL communication error, please report this issue to b.android.com.\n");
704 abort();
705 }
706 }
707 return retval;
708 }
709
rcMakeCurrent_enc(void * self,uint32_t context,uint32_t drawSurf,uint32_t readSurf)710 EGLint rcMakeCurrent_enc(void *self , uint32_t context, uint32_t drawSurf, uint32_t readSurf)
711 {
712 ENCODER_DEBUG_LOG("rcMakeCurrent(context:0x%08x, drawSurf:0x%08x, readSurf:0x%08x)", context, drawSurf, readSurf);
713 AEMU_SCOPED_TRACE("rcMakeCurrent encode");
714
715 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
716 IOStream *stream = ctx->m_stream;
717 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
718 bool useChecksum = checksumCalculator->getVersion() > 0;
719
720 unsigned char *ptr;
721 unsigned char *buf;
722 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
723 const size_t checksumSize = checksumCalculator->checksumByteSize();
724 const size_t totalSize = sizeWithoutChecksum + checksumSize;
725 buf = stream->alloc(totalSize);
726 ptr = buf;
727 int tmp = OP_rcMakeCurrent;memcpy(ptr, &tmp, 4); ptr += 4;
728 memcpy(ptr, &totalSize, 4); ptr += 4;
729
730 memcpy(ptr, &context, 4); ptr += 4;
731 memcpy(ptr, &drawSurf, 4); ptr += 4;
732 memcpy(ptr, &readSurf, 4); ptr += 4;
733
734 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
735 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
736
737
738 EGLint retval;
739 stream->readback(&retval, 4);
740 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
741 if (useChecksum) {
742 unsigned char *checksumBufPtr = NULL;
743 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
744 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
745 stream->readback(checksumBufPtr, checksumSize);
746 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
747 ALOGE("rcMakeCurrent: GL communication error, please report this issue to b.android.com.\n");
748 abort();
749 }
750 }
751 return retval;
752 }
753
rcFBPost_enc(void * self,uint32_t colorBuffer)754 void rcFBPost_enc(void *self , uint32_t colorBuffer)
755 {
756 ENCODER_DEBUG_LOG("rcFBPost(colorBuffer:0x%08x)", colorBuffer);
757 AEMU_SCOPED_TRACE("rcFBPost encode");
758
759 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
760 IOStream *stream = ctx->m_stream;
761 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
762 bool useChecksum = checksumCalculator->getVersion() > 0;
763
764 unsigned char *ptr;
765 unsigned char *buf;
766 const size_t sizeWithoutChecksum = 8 + 4;
767 const size_t checksumSize = checksumCalculator->checksumByteSize();
768 const size_t totalSize = sizeWithoutChecksum + checksumSize;
769 buf = stream->alloc(totalSize);
770 ptr = buf;
771 int tmp = OP_rcFBPost;memcpy(ptr, &tmp, 4); ptr += 4;
772 memcpy(ptr, &totalSize, 4); ptr += 4;
773
774 memcpy(ptr, &colorBuffer, 4); ptr += 4;
775
776 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
777 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
778
779 }
780
rcFBSetSwapInterval_enc(void * self,EGLint interval)781 void rcFBSetSwapInterval_enc(void *self , EGLint interval)
782 {
783 ENCODER_DEBUG_LOG("rcFBSetSwapInterval(interval:0x%08x)", interval);
784 AEMU_SCOPED_TRACE("rcFBSetSwapInterval encode");
785
786 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
787 IOStream *stream = ctx->m_stream;
788 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
789 bool useChecksum = checksumCalculator->getVersion() > 0;
790
791 unsigned char *ptr;
792 unsigned char *buf;
793 const size_t sizeWithoutChecksum = 8 + 4;
794 const size_t checksumSize = checksumCalculator->checksumByteSize();
795 const size_t totalSize = sizeWithoutChecksum + checksumSize;
796 buf = stream->alloc(totalSize);
797 ptr = buf;
798 int tmp = OP_rcFBSetSwapInterval;memcpy(ptr, &tmp, 4); ptr += 4;
799 memcpy(ptr, &totalSize, 4); ptr += 4;
800
801 memcpy(ptr, &interval, 4); ptr += 4;
802
803 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
804 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
805
806 }
807
rcBindTexture_enc(void * self,uint32_t colorBuffer)808 void rcBindTexture_enc(void *self , uint32_t colorBuffer)
809 {
810 ENCODER_DEBUG_LOG("rcBindTexture(colorBuffer:0x%08x)", colorBuffer);
811 AEMU_SCOPED_TRACE("rcBindTexture encode");
812
813 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
814 IOStream *stream = ctx->m_stream;
815 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
816 bool useChecksum = checksumCalculator->getVersion() > 0;
817
818 unsigned char *ptr;
819 unsigned char *buf;
820 const size_t sizeWithoutChecksum = 8 + 4;
821 const size_t checksumSize = checksumCalculator->checksumByteSize();
822 const size_t totalSize = sizeWithoutChecksum + checksumSize;
823 buf = stream->alloc(totalSize);
824 ptr = buf;
825 int tmp = OP_rcBindTexture;memcpy(ptr, &tmp, 4); ptr += 4;
826 memcpy(ptr, &totalSize, 4); ptr += 4;
827
828 memcpy(ptr, &colorBuffer, 4); ptr += 4;
829
830 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
831 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
832
833 }
834
rcBindRenderbuffer_enc(void * self,uint32_t colorBuffer)835 void rcBindRenderbuffer_enc(void *self , uint32_t colorBuffer)
836 {
837 ENCODER_DEBUG_LOG("rcBindRenderbuffer(colorBuffer:0x%08x)", colorBuffer);
838 AEMU_SCOPED_TRACE("rcBindRenderbuffer encode");
839
840 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
841 IOStream *stream = ctx->m_stream;
842 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
843 bool useChecksum = checksumCalculator->getVersion() > 0;
844
845 unsigned char *ptr;
846 unsigned char *buf;
847 const size_t sizeWithoutChecksum = 8 + 4;
848 const size_t checksumSize = checksumCalculator->checksumByteSize();
849 const size_t totalSize = sizeWithoutChecksum + checksumSize;
850 buf = stream->alloc(totalSize);
851 ptr = buf;
852 int tmp = OP_rcBindRenderbuffer;memcpy(ptr, &tmp, 4); ptr += 4;
853 memcpy(ptr, &totalSize, 4); ptr += 4;
854
855 memcpy(ptr, &colorBuffer, 4); ptr += 4;
856
857 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
858 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
859
860 }
861
rcColorBufferCacheFlush_enc(void * self,uint32_t colorbuffer,EGLint postCount,int forRead)862 EGLint rcColorBufferCacheFlush_enc(void *self , uint32_t colorbuffer, EGLint postCount, int forRead)
863 {
864 ENCODER_DEBUG_LOG("rcColorBufferCacheFlush(colorbuffer:0x%08x, postCount:0x%08x, forRead:%d)", colorbuffer, postCount, forRead);
865 AEMU_SCOPED_TRACE("rcColorBufferCacheFlush encode");
866
867 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
868 IOStream *stream = ctx->m_stream;
869 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
870 bool useChecksum = checksumCalculator->getVersion() > 0;
871
872 unsigned char *ptr;
873 unsigned char *buf;
874 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
875 const size_t checksumSize = checksumCalculator->checksumByteSize();
876 const size_t totalSize = sizeWithoutChecksum + checksumSize;
877 buf = stream->alloc(totalSize);
878 ptr = buf;
879 int tmp = OP_rcColorBufferCacheFlush;memcpy(ptr, &tmp, 4); ptr += 4;
880 memcpy(ptr, &totalSize, 4); ptr += 4;
881
882 memcpy(ptr, &colorbuffer, 4); ptr += 4;
883 memcpy(ptr, &postCount, 4); ptr += 4;
884 memcpy(ptr, &forRead, 4); ptr += 4;
885
886 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
887 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
888
889
890 EGLint retval;
891 stream->readback(&retval, 4);
892 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
893 if (useChecksum) {
894 unsigned char *checksumBufPtr = NULL;
895 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
896 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
897 stream->readback(checksumBufPtr, checksumSize);
898 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
899 ALOGE("rcColorBufferCacheFlush: GL communication error, please report this issue to b.android.com.\n");
900 abort();
901 }
902 }
903 return retval;
904 }
905
rcReadColorBuffer_enc(void * self,uint32_t colorbuffer,GLint x,GLint y,GLint width,GLint height,GLenum format,GLenum type,void * pixels)906 void rcReadColorBuffer_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels)
907 {
908 ENCODER_DEBUG_LOG("rcReadColorBuffer(colorbuffer:0x%08x, x:0x%08x, y:0x%08x, width:0x%08x, height:0x%08x, format:0x%08x, type:0x%08x, pixels:0x%08x)", colorbuffer, x, y, width, height, format, type, pixels);
909 AEMU_SCOPED_TRACE("rcReadColorBuffer encode");
910
911 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
912 IOStream *stream = ctx->m_stream;
913 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
914 bool useChecksum = checksumCalculator->getVersion() > 0;
915
916 const unsigned int __size_pixels = (((glUtilsPixelBitSize(format, type) * width) >> 3) * height);
917 unsigned char *ptr;
918 unsigned char *buf;
919 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 0 + 1*4;
920 const size_t checksumSize = checksumCalculator->checksumByteSize();
921 const size_t totalSize = sizeWithoutChecksum + checksumSize;
922 buf = stream->alloc(totalSize);
923 ptr = buf;
924 int tmp = OP_rcReadColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
925 memcpy(ptr, &totalSize, 4); ptr += 4;
926
927 memcpy(ptr, &colorbuffer, 4); ptr += 4;
928 memcpy(ptr, &x, 4); ptr += 4;
929 memcpy(ptr, &y, 4); ptr += 4;
930 memcpy(ptr, &width, 4); ptr += 4;
931 memcpy(ptr, &height, 4); ptr += 4;
932 memcpy(ptr, &format, 4); ptr += 4;
933 memcpy(ptr, &type, 4); ptr += 4;
934 memcpy(ptr, &__size_pixels, 4); ptr += 4;
935
936 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
937 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
938
939 stream->readback(pixels, __size_pixels);
940 if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
941 if (useChecksum) {
942 unsigned char *checksumBufPtr = NULL;
943 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
944 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
945 stream->readback(checksumBufPtr, checksumSize);
946 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
947 ALOGE("rcReadColorBuffer: GL communication error, please report this issue to b.android.com.\n");
948 abort();
949 }
950 }
951 }
952
rcUpdateColorBuffer_enc(void * self,uint32_t colorbuffer,GLint x,GLint y,GLint width,GLint height,GLenum format,GLenum type,void * pixels)953 int rcUpdateColorBuffer_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels)
954 {
955 ENCODER_DEBUG_LOG("rcUpdateColorBuffer(colorbuffer:0x%08x, x:0x%08x, y:0x%08x, width:0x%08x, height:0x%08x, format:0x%08x, type:0x%08x, pixels:0x%08x)", colorbuffer, x, y, width, height, format, type, pixels);
956 AEMU_SCOPED_TRACE("rcUpdateColorBuffer encode");
957
958 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
959 IOStream *stream = ctx->m_stream;
960 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
961 bool useChecksum = checksumCalculator->getVersion() > 0;
962
963 const unsigned int __size_pixels = (((glUtilsPixelBitSize(format, type) * width) >> 3) * height);
964 unsigned char *ptr;
965 unsigned char *buf;
966 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
967 const size_t checksumSize = checksumCalculator->checksumByteSize();
968 const size_t totalSize = sizeWithoutChecksum + checksumSize;
969 buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
970 ptr = buf;
971 int tmp = OP_rcUpdateColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
972 memcpy(ptr, &totalSize, 4); ptr += 4;
973
974 memcpy(ptr, &colorbuffer, 4); ptr += 4;
975 memcpy(ptr, &x, 4); ptr += 4;
976 memcpy(ptr, &y, 4); ptr += 4;
977 memcpy(ptr, &width, 4); ptr += 4;
978 memcpy(ptr, &height, 4); ptr += 4;
979 memcpy(ptr, &format, 4); ptr += 4;
980 memcpy(ptr, &type, 4); ptr += 4;
981
982 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
983 stream->flush();
984 stream->writeFully(&__size_pixels,4);
985 if (useChecksum) checksumCalculator->addBuffer(&__size_pixels,4);
986 stream->writeFully(pixels, __size_pixels);
987 if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
988 buf = stream->alloc(checksumSize);
989 if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
990
991
992 int retval;
993 stream->readback(&retval, 4);
994 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
995 if (useChecksum) {
996 unsigned char *checksumBufPtr = NULL;
997 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
998 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
999 stream->readback(checksumBufPtr, checksumSize);
1000 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1001 ALOGE("rcUpdateColorBuffer: GL communication error, please report this issue to b.android.com.\n");
1002 abort();
1003 }
1004 }
1005 return retval;
1006 }
1007
rcOpenColorBuffer2_enc(void * self,uint32_t colorbuffer)1008 int rcOpenColorBuffer2_enc(void *self , uint32_t colorbuffer)
1009 {
1010 ENCODER_DEBUG_LOG("rcOpenColorBuffer2(colorbuffer:0x%08x)", colorbuffer);
1011 AEMU_SCOPED_TRACE("rcOpenColorBuffer2 encode");
1012
1013 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1014 IOStream *stream = ctx->m_stream;
1015 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1016 bool useChecksum = checksumCalculator->getVersion() > 0;
1017
1018 unsigned char *ptr;
1019 unsigned char *buf;
1020 const size_t sizeWithoutChecksum = 8 + 4;
1021 const size_t checksumSize = checksumCalculator->checksumByteSize();
1022 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1023 buf = stream->alloc(totalSize);
1024 ptr = buf;
1025 int tmp = OP_rcOpenColorBuffer2;memcpy(ptr, &tmp, 4); ptr += 4;
1026 memcpy(ptr, &totalSize, 4); ptr += 4;
1027
1028 memcpy(ptr, &colorbuffer, 4); ptr += 4;
1029
1030 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1031 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1032
1033
1034 int retval;
1035 stream->readback(&retval, 4);
1036 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1037 if (useChecksum) {
1038 unsigned char *checksumBufPtr = NULL;
1039 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1040 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1041 stream->readback(checksumBufPtr, checksumSize);
1042 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1043 ALOGE("rcOpenColorBuffer2: GL communication error, please report this issue to b.android.com.\n");
1044 abort();
1045 }
1046 }
1047 return retval;
1048 }
1049
rcCreateClientImage_enc(void * self,uint32_t context,EGLenum target,GLuint buffer)1050 uint32_t rcCreateClientImage_enc(void *self , uint32_t context, EGLenum target, GLuint buffer)
1051 {
1052 ENCODER_DEBUG_LOG("rcCreateClientImage(context:0x%08x, target:0x%08x, buffer:0x%08x)", context, target, buffer);
1053 AEMU_SCOPED_TRACE("rcCreateClientImage encode");
1054
1055 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1056 IOStream *stream = ctx->m_stream;
1057 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1058 bool useChecksum = checksumCalculator->getVersion() > 0;
1059
1060 unsigned char *ptr;
1061 unsigned char *buf;
1062 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
1063 const size_t checksumSize = checksumCalculator->checksumByteSize();
1064 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1065 buf = stream->alloc(totalSize);
1066 ptr = buf;
1067 int tmp = OP_rcCreateClientImage;memcpy(ptr, &tmp, 4); ptr += 4;
1068 memcpy(ptr, &totalSize, 4); ptr += 4;
1069
1070 memcpy(ptr, &context, 4); ptr += 4;
1071 memcpy(ptr, &target, 4); ptr += 4;
1072 memcpy(ptr, &buffer, 4); ptr += 4;
1073
1074 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1075 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1076
1077
1078 uint32_t retval;
1079 stream->readback(&retval, 4);
1080 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1081 if (useChecksum) {
1082 unsigned char *checksumBufPtr = NULL;
1083 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1084 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1085 stream->readback(checksumBufPtr, checksumSize);
1086 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1087 ALOGE("rcCreateClientImage: GL communication error, please report this issue to b.android.com.\n");
1088 abort();
1089 }
1090 }
1091 return retval;
1092 }
1093
rcDestroyClientImage_enc(void * self,uint32_t image)1094 int rcDestroyClientImage_enc(void *self , uint32_t image)
1095 {
1096 ENCODER_DEBUG_LOG("rcDestroyClientImage(image:0x%08x)", image);
1097 AEMU_SCOPED_TRACE("rcDestroyClientImage encode");
1098
1099 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1100 IOStream *stream = ctx->m_stream;
1101 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1102 bool useChecksum = checksumCalculator->getVersion() > 0;
1103
1104 unsigned char *ptr;
1105 unsigned char *buf;
1106 const size_t sizeWithoutChecksum = 8 + 4;
1107 const size_t checksumSize = checksumCalculator->checksumByteSize();
1108 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1109 buf = stream->alloc(totalSize);
1110 ptr = buf;
1111 int tmp = OP_rcDestroyClientImage;memcpy(ptr, &tmp, 4); ptr += 4;
1112 memcpy(ptr, &totalSize, 4); ptr += 4;
1113
1114 memcpy(ptr, &image, 4); ptr += 4;
1115
1116 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1117 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1118
1119
1120 int retval;
1121 stream->readback(&retval, 4);
1122 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1123 if (useChecksum) {
1124 unsigned char *checksumBufPtr = NULL;
1125 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1126 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1127 stream->readback(checksumBufPtr, checksumSize);
1128 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1129 ALOGE("rcDestroyClientImage: GL communication error, please report this issue to b.android.com.\n");
1130 abort();
1131 }
1132 }
1133 return retval;
1134 }
1135
rcSelectChecksumHelper_enc(void * self,uint32_t newProtocol,uint32_t reserved)1136 void rcSelectChecksumHelper_enc(void *self , uint32_t newProtocol, uint32_t reserved)
1137 {
1138 ENCODER_DEBUG_LOG("rcSelectChecksumHelper(newProtocol:0x%08x, reserved:0x%08x)", newProtocol, reserved);
1139 AEMU_SCOPED_TRACE("rcSelectChecksumHelper encode");
1140
1141 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1142 IOStream *stream = ctx->m_stream;
1143 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1144 bool useChecksum = checksumCalculator->getVersion() > 0;
1145
1146 unsigned char *ptr;
1147 unsigned char *buf;
1148 const size_t sizeWithoutChecksum = 8 + 4 + 4;
1149 const size_t checksumSize = checksumCalculator->checksumByteSize();
1150 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1151 buf = stream->alloc(totalSize);
1152 ptr = buf;
1153 int tmp = OP_rcSelectChecksumHelper;memcpy(ptr, &tmp, 4); ptr += 4;
1154 memcpy(ptr, &totalSize, 4); ptr += 4;
1155
1156 memcpy(ptr, &newProtocol, 4); ptr += 4;
1157 memcpy(ptr, &reserved, 4); ptr += 4;
1158
1159 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1160 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1161
1162 }
1163
rcCreateSyncKHR_enc(void * self,EGLenum type,EGLint * attribs,uint32_t num_attribs,int destroy_when_signaled,uint64_t * glsync_out,uint64_t * syncthread_out)1164 void rcCreateSyncKHR_enc(void *self , EGLenum type, EGLint* attribs, uint32_t num_attribs, int destroy_when_signaled, uint64_t* glsync_out, uint64_t* syncthread_out)
1165 {
1166 ENCODER_DEBUG_LOG("rcCreateSyncKHR(type:0x%08x, attribs:0x%08x, num_attribs:0x%08x, destroy_when_signaled:%d, glsync_out:0x%08x, syncthread_out:0x%08x)", type, attribs, num_attribs, destroy_when_signaled, glsync_out, syncthread_out);
1167 AEMU_SCOPED_TRACE("rcCreateSyncKHR encode");
1168
1169 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1170 IOStream *stream = ctx->m_stream;
1171 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1172 bool useChecksum = checksumCalculator->getVersion() > 0;
1173
1174 const unsigned int __size_attribs = num_attribs;
1175 const unsigned int __size_glsync_out = sizeof(uint64_t);
1176 const unsigned int __size_syncthread_out = sizeof(uint64_t);
1177 unsigned char *ptr;
1178 unsigned char *buf;
1179 const size_t sizeWithoutChecksum = 8 + 4 + __size_attribs + 4 + 4 + 0 + 0 + 3*4;
1180 const size_t checksumSize = checksumCalculator->checksumByteSize();
1181 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1182 buf = stream->alloc(totalSize);
1183 ptr = buf;
1184 int tmp = OP_rcCreateSyncKHR;memcpy(ptr, &tmp, 4); ptr += 4;
1185 memcpy(ptr, &totalSize, 4); ptr += 4;
1186
1187 memcpy(ptr, &type, 4); ptr += 4;
1188 memcpy(ptr, &__size_attribs, 4); ptr += 4;
1189 memcpy(ptr, attribs, __size_attribs);ptr += __size_attribs;
1190 memcpy(ptr, &num_attribs, 4); ptr += 4;
1191 memcpy(ptr, &destroy_when_signaled, 4); ptr += 4;
1192 memcpy(ptr, &__size_glsync_out, 4); ptr += 4;
1193 memcpy(ptr, &__size_syncthread_out, 4); ptr += 4;
1194
1195 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1196 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1197
1198 stream->readback(glsync_out, __size_glsync_out);
1199 if (useChecksum) checksumCalculator->addBuffer(glsync_out, __size_glsync_out);
1200 stream->readback(syncthread_out, __size_syncthread_out);
1201 if (useChecksum) checksumCalculator->addBuffer(syncthread_out, __size_syncthread_out);
1202 if (useChecksum) {
1203 unsigned char *checksumBufPtr = NULL;
1204 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1205 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1206 stream->readback(checksumBufPtr, checksumSize);
1207 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1208 ALOGE("rcCreateSyncKHR: GL communication error, please report this issue to b.android.com.\n");
1209 abort();
1210 }
1211 }
1212 }
1213
rcClientWaitSyncKHR_enc(void * self,uint64_t sync,EGLint flags,uint64_t timeout)1214 EGLint rcClientWaitSyncKHR_enc(void *self , uint64_t sync, EGLint flags, uint64_t timeout)
1215 {
1216 ENCODER_DEBUG_LOG("rcClientWaitSyncKHR(sync:0x%016lx, flags:0x%08x, timeout:0x%016lx)", sync, flags, timeout);
1217 AEMU_SCOPED_TRACE("rcClientWaitSyncKHR encode");
1218
1219 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1220 IOStream *stream = ctx->m_stream;
1221 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1222 bool useChecksum = checksumCalculator->getVersion() > 0;
1223
1224 unsigned char *ptr;
1225 unsigned char *buf;
1226 const size_t sizeWithoutChecksum = 8 + 8 + 4 + 8;
1227 const size_t checksumSize = checksumCalculator->checksumByteSize();
1228 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1229 buf = stream->alloc(totalSize);
1230 ptr = buf;
1231 int tmp = OP_rcClientWaitSyncKHR;memcpy(ptr, &tmp, 4); ptr += 4;
1232 memcpy(ptr, &totalSize, 4); ptr += 4;
1233
1234 memcpy(ptr, &sync, 8); ptr += 8;
1235 memcpy(ptr, &flags, 4); ptr += 4;
1236 memcpy(ptr, &timeout, 8); ptr += 8;
1237
1238 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1239 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1240
1241
1242 EGLint retval;
1243 stream->readback(&retval, 4);
1244 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1245 if (useChecksum) {
1246 unsigned char *checksumBufPtr = NULL;
1247 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1248 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1249 stream->readback(checksumBufPtr, checksumSize);
1250 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1251 ALOGE("rcClientWaitSyncKHR: GL communication error, please report this issue to b.android.com.\n");
1252 abort();
1253 }
1254 }
1255 return retval;
1256 }
1257
rcFlushWindowColorBufferAsync_enc(void * self,uint32_t windowSurface)1258 void rcFlushWindowColorBufferAsync_enc(void *self , uint32_t windowSurface)
1259 {
1260 ENCODER_DEBUG_LOG("rcFlushWindowColorBufferAsync(windowSurface:0x%08x)", windowSurface);
1261 AEMU_SCOPED_TRACE("rcFlushWindowColorBufferAsync encode");
1262
1263 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1264 IOStream *stream = ctx->m_stream;
1265 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1266 bool useChecksum = checksumCalculator->getVersion() > 0;
1267
1268 unsigned char *ptr;
1269 unsigned char *buf;
1270 const size_t sizeWithoutChecksum = 8 + 4;
1271 const size_t checksumSize = checksumCalculator->checksumByteSize();
1272 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1273 buf = stream->alloc(totalSize);
1274 ptr = buf;
1275 int tmp = OP_rcFlushWindowColorBufferAsync;memcpy(ptr, &tmp, 4); ptr += 4;
1276 memcpy(ptr, &totalSize, 4); ptr += 4;
1277
1278 memcpy(ptr, &windowSurface, 4); ptr += 4;
1279
1280 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1281 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1282
1283 }
1284
rcDestroySyncKHR_enc(void * self,uint64_t sync)1285 int rcDestroySyncKHR_enc(void *self , uint64_t sync)
1286 {
1287 ENCODER_DEBUG_LOG("rcDestroySyncKHR(sync:0x%016lx)", sync);
1288 AEMU_SCOPED_TRACE("rcDestroySyncKHR encode");
1289
1290 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1291 IOStream *stream = ctx->m_stream;
1292 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1293 bool useChecksum = checksumCalculator->getVersion() > 0;
1294
1295 unsigned char *ptr;
1296 unsigned char *buf;
1297 const size_t sizeWithoutChecksum = 8 + 8;
1298 const size_t checksumSize = checksumCalculator->checksumByteSize();
1299 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1300 buf = stream->alloc(totalSize);
1301 ptr = buf;
1302 int tmp = OP_rcDestroySyncKHR;memcpy(ptr, &tmp, 4); ptr += 4;
1303 memcpy(ptr, &totalSize, 4); ptr += 4;
1304
1305 memcpy(ptr, &sync, 8); ptr += 8;
1306
1307 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1308 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1309
1310
1311 int retval;
1312 stream->readback(&retval, 4);
1313 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1314 if (useChecksum) {
1315 unsigned char *checksumBufPtr = NULL;
1316 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1317 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1318 stream->readback(checksumBufPtr, checksumSize);
1319 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1320 ALOGE("rcDestroySyncKHR: GL communication error, please report this issue to b.android.com.\n");
1321 abort();
1322 }
1323 }
1324 return retval;
1325 }
1326
rcSetPuid_enc(void * self,uint64_t puid)1327 void rcSetPuid_enc(void *self , uint64_t puid)
1328 {
1329 ENCODER_DEBUG_LOG("rcSetPuid(puid:0x%016lx)", puid);
1330 AEMU_SCOPED_TRACE("rcSetPuid encode");
1331
1332 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1333 IOStream *stream = ctx->m_stream;
1334 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1335 bool useChecksum = checksumCalculator->getVersion() > 0;
1336
1337 unsigned char *ptr;
1338 unsigned char *buf;
1339 const size_t sizeWithoutChecksum = 8 + 8;
1340 const size_t checksumSize = checksumCalculator->checksumByteSize();
1341 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1342 buf = stream->alloc(totalSize);
1343 ptr = buf;
1344 int tmp = OP_rcSetPuid;memcpy(ptr, &tmp, 4); ptr += 4;
1345 memcpy(ptr, &totalSize, 4); ptr += 4;
1346
1347 memcpy(ptr, &puid, 8); ptr += 8;
1348
1349 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1350 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1351
1352 }
1353
rcUpdateColorBufferDMA_enc(void * self,uint32_t colorbuffer,GLint x,GLint y,GLint width,GLint height,GLenum format,GLenum type,void * pixels,uint32_t pixels_size)1354 int rcUpdateColorBufferDMA_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels, uint32_t pixels_size)
1355 {
1356 ENCODER_DEBUG_LOG("rcUpdateColorBufferDMA(colorbuffer:0x%08x, x:0x%08x, y:0x%08x, width:0x%08x, height:0x%08x, format:0x%08x, type:0x%08x, pixels:0x%08x, pixels_size:0x%08x)", colorbuffer, x, y, width, height, format, type, pixels, pixels_size);
1357 AEMU_SCOPED_TRACE("rcUpdateColorBufferDMA encode");
1358
1359 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1360 IOStream *stream = ctx->m_stream;
1361 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1362 bool useChecksum = checksumCalculator->getVersion() > 0;
1363
1364 const unsigned int __size_pixels = pixels_size;
1365 unsigned char *ptr;
1366 unsigned char *buf;
1367 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 8 + 4 + 1*4;
1368 const size_t checksumSize = checksumCalculator->checksumByteSize();
1369 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1370 buf = stream->alloc(totalSize);
1371 ptr = buf;
1372 int tmp = OP_rcUpdateColorBufferDMA;memcpy(ptr, &tmp, 4); ptr += 4;
1373 memcpy(ptr, &totalSize, 4); ptr += 4;
1374
1375 memcpy(ptr, &colorbuffer, 4); ptr += 4;
1376 memcpy(ptr, &x, 4); ptr += 4;
1377 memcpy(ptr, &y, 4); ptr += 4;
1378 memcpy(ptr, &width, 4); ptr += 4;
1379 memcpy(ptr, &height, 4); ptr += 4;
1380 memcpy(ptr, &format, 4); ptr += 4;
1381 memcpy(ptr, &type, 4); ptr += 4;
1382 *(uint64_t *)(ptr) = ctx->lockAndWriteDma(pixels, __size_pixels); ptr += 8;
1383 memcpy(ptr, &pixels_size, 4); ptr += 4;
1384
1385 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1386 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1387
1388
1389 int retval;
1390 stream->readback(&retval, 4);
1391 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1392 if (useChecksum) {
1393 unsigned char *checksumBufPtr = NULL;
1394 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1395 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1396 stream->readback(checksumBufPtr, checksumSize);
1397 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1398 ALOGE("rcUpdateColorBufferDMA: GL communication error, please report this issue to b.android.com.\n");
1399 abort();
1400 }
1401 }
1402 return retval;
1403 }
1404
rcCreateColorBufferDMA_enc(void * self,uint32_t width,uint32_t height,GLenum internalFormat,int frameworkFormat)1405 uint32_t rcCreateColorBufferDMA_enc(void *self , uint32_t width, uint32_t height, GLenum internalFormat, int frameworkFormat)
1406 {
1407 ENCODER_DEBUG_LOG("rcCreateColorBufferDMA(width:0x%08x, height:0x%08x, internalFormat:0x%08x, frameworkFormat:%d)", width, height, internalFormat, frameworkFormat);
1408 AEMU_SCOPED_TRACE("rcCreateColorBufferDMA encode");
1409
1410 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1411 IOStream *stream = ctx->m_stream;
1412 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1413 bool useChecksum = checksumCalculator->getVersion() > 0;
1414
1415 unsigned char *ptr;
1416 unsigned char *buf;
1417 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
1418 const size_t checksumSize = checksumCalculator->checksumByteSize();
1419 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1420 buf = stream->alloc(totalSize);
1421 ptr = buf;
1422 int tmp = OP_rcCreateColorBufferDMA;memcpy(ptr, &tmp, 4); ptr += 4;
1423 memcpy(ptr, &totalSize, 4); ptr += 4;
1424
1425 memcpy(ptr, &width, 4); ptr += 4;
1426 memcpy(ptr, &height, 4); ptr += 4;
1427 memcpy(ptr, &internalFormat, 4); ptr += 4;
1428 memcpy(ptr, &frameworkFormat, 4); ptr += 4;
1429
1430 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1431 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1432
1433
1434 uint32_t retval;
1435 stream->readback(&retval, 4);
1436 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1437 if (useChecksum) {
1438 unsigned char *checksumBufPtr = NULL;
1439 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1440 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1441 stream->readback(checksumBufPtr, checksumSize);
1442 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1443 ALOGE("rcCreateColorBufferDMA: GL communication error, please report this issue to b.android.com.\n");
1444 abort();
1445 }
1446 }
1447 return retval;
1448 }
1449
rcWaitSyncKHR_enc(void * self,uint64_t sync,EGLint flags)1450 void rcWaitSyncKHR_enc(void *self , uint64_t sync, EGLint flags)
1451 {
1452 ENCODER_DEBUG_LOG("rcWaitSyncKHR(sync:0x%016lx, flags:0x%08x)", sync, flags);
1453 AEMU_SCOPED_TRACE("rcWaitSyncKHR encode");
1454
1455 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1456 IOStream *stream = ctx->m_stream;
1457 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1458 bool useChecksum = checksumCalculator->getVersion() > 0;
1459
1460 unsigned char *ptr;
1461 unsigned char *buf;
1462 const size_t sizeWithoutChecksum = 8 + 8 + 4;
1463 const size_t checksumSize = checksumCalculator->checksumByteSize();
1464 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1465 buf = stream->alloc(totalSize);
1466 ptr = buf;
1467 int tmp = OP_rcWaitSyncKHR;memcpy(ptr, &tmp, 4); ptr += 4;
1468 memcpy(ptr, &totalSize, 4); ptr += 4;
1469
1470 memcpy(ptr, &sync, 8); ptr += 8;
1471 memcpy(ptr, &flags, 4); ptr += 4;
1472
1473 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1474 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1475
1476 }
1477
rcCompose_enc(void * self,uint32_t bufferSize,void * buffer)1478 GLint rcCompose_enc(void *self , uint32_t bufferSize, void* buffer)
1479 {
1480 ENCODER_DEBUG_LOG("rcCompose(bufferSize:0x%08x, buffer:0x%08x)", bufferSize, buffer);
1481 AEMU_SCOPED_TRACE("rcCompose encode");
1482
1483 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1484 IOStream *stream = ctx->m_stream;
1485 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1486 bool useChecksum = checksumCalculator->getVersion() > 0;
1487
1488 const unsigned int __size_buffer = bufferSize;
1489 unsigned char *ptr;
1490 unsigned char *buf;
1491 const size_t sizeWithoutChecksum = 8 + 4 + __size_buffer + 1*4;
1492 const size_t checksumSize = checksumCalculator->checksumByteSize();
1493 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1494 buf = stream->alloc(totalSize);
1495 ptr = buf;
1496 int tmp = OP_rcCompose;memcpy(ptr, &tmp, 4); ptr += 4;
1497 memcpy(ptr, &totalSize, 4); ptr += 4;
1498
1499 memcpy(ptr, &bufferSize, 4); ptr += 4;
1500 memcpy(ptr, &__size_buffer, 4); ptr += 4;
1501 memcpy(ptr, buffer, __size_buffer);ptr += __size_buffer;
1502
1503 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1504 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1505
1506
1507 GLint retval;
1508 stream->readback(&retval, 4);
1509 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1510 if (useChecksum) {
1511 unsigned char *checksumBufPtr = NULL;
1512 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1513 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1514 stream->readback(checksumBufPtr, checksumSize);
1515 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1516 ALOGE("rcCompose: GL communication error, please report this issue to b.android.com.\n");
1517 abort();
1518 }
1519 }
1520 return retval;
1521 }
1522
rcCreateDisplay_enc(void * self,uint32_t * displayId)1523 int rcCreateDisplay_enc(void *self , uint32_t* displayId)
1524 {
1525 ENCODER_DEBUG_LOG("rcCreateDisplay(displayId:0x%08x)", displayId);
1526 AEMU_SCOPED_TRACE("rcCreateDisplay encode");
1527
1528 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1529 IOStream *stream = ctx->m_stream;
1530 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1531 bool useChecksum = checksumCalculator->getVersion() > 0;
1532
1533 const unsigned int __size_displayId = sizeof(uint32_t);
1534 unsigned char *ptr;
1535 unsigned char *buf;
1536 const size_t sizeWithoutChecksum = 8 + 0 + 1*4;
1537 const size_t checksumSize = checksumCalculator->checksumByteSize();
1538 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1539 buf = stream->alloc(totalSize);
1540 ptr = buf;
1541 int tmp = OP_rcCreateDisplay;memcpy(ptr, &tmp, 4); ptr += 4;
1542 memcpy(ptr, &totalSize, 4); ptr += 4;
1543
1544 memcpy(ptr, &__size_displayId, 4); ptr += 4;
1545
1546 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1547 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1548
1549 stream->readback(displayId, __size_displayId);
1550 if (useChecksum) checksumCalculator->addBuffer(displayId, __size_displayId);
1551
1552 int retval;
1553 stream->readback(&retval, 4);
1554 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1555 if (useChecksum) {
1556 unsigned char *checksumBufPtr = NULL;
1557 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1558 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1559 stream->readback(checksumBufPtr, checksumSize);
1560 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1561 ALOGE("rcCreateDisplay: GL communication error, please report this issue to b.android.com.\n");
1562 abort();
1563 }
1564 }
1565 return retval;
1566 }
1567
rcDestroyDisplay_enc(void * self,uint32_t displayId)1568 int rcDestroyDisplay_enc(void *self , uint32_t displayId)
1569 {
1570 ENCODER_DEBUG_LOG("rcDestroyDisplay(displayId:0x%08x)", displayId);
1571 AEMU_SCOPED_TRACE("rcDestroyDisplay encode");
1572
1573 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1574 IOStream *stream = ctx->m_stream;
1575 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1576 bool useChecksum = checksumCalculator->getVersion() > 0;
1577
1578 unsigned char *ptr;
1579 unsigned char *buf;
1580 const size_t sizeWithoutChecksum = 8 + 4;
1581 const size_t checksumSize = checksumCalculator->checksumByteSize();
1582 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1583 buf = stream->alloc(totalSize);
1584 ptr = buf;
1585 int tmp = OP_rcDestroyDisplay;memcpy(ptr, &tmp, 4); ptr += 4;
1586 memcpy(ptr, &totalSize, 4); ptr += 4;
1587
1588 memcpy(ptr, &displayId, 4); ptr += 4;
1589
1590 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1591 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1592
1593
1594 int retval;
1595 stream->readback(&retval, 4);
1596 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1597 if (useChecksum) {
1598 unsigned char *checksumBufPtr = NULL;
1599 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1600 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1601 stream->readback(checksumBufPtr, checksumSize);
1602 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1603 ALOGE("rcDestroyDisplay: GL communication error, please report this issue to b.android.com.\n");
1604 abort();
1605 }
1606 }
1607 return retval;
1608 }
1609
rcSetDisplayColorBuffer_enc(void * self,uint32_t displayId,uint32_t colorBuffer)1610 int rcSetDisplayColorBuffer_enc(void *self , uint32_t displayId, uint32_t colorBuffer)
1611 {
1612 ENCODER_DEBUG_LOG("rcSetDisplayColorBuffer(displayId:0x%08x, colorBuffer:0x%08x)", displayId, colorBuffer);
1613 AEMU_SCOPED_TRACE("rcSetDisplayColorBuffer encode");
1614
1615 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1616 IOStream *stream = ctx->m_stream;
1617 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1618 bool useChecksum = checksumCalculator->getVersion() > 0;
1619
1620 unsigned char *ptr;
1621 unsigned char *buf;
1622 const size_t sizeWithoutChecksum = 8 + 4 + 4;
1623 const size_t checksumSize = checksumCalculator->checksumByteSize();
1624 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1625 buf = stream->alloc(totalSize);
1626 ptr = buf;
1627 int tmp = OP_rcSetDisplayColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
1628 memcpy(ptr, &totalSize, 4); ptr += 4;
1629
1630 memcpy(ptr, &displayId, 4); ptr += 4;
1631 memcpy(ptr, &colorBuffer, 4); ptr += 4;
1632
1633 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1634 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1635
1636
1637 int retval;
1638 stream->readback(&retval, 4);
1639 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1640 if (useChecksum) {
1641 unsigned char *checksumBufPtr = NULL;
1642 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1643 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1644 stream->readback(checksumBufPtr, checksumSize);
1645 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1646 ALOGE("rcSetDisplayColorBuffer: GL communication error, please report this issue to b.android.com.\n");
1647 abort();
1648 }
1649 }
1650 return retval;
1651 }
1652
rcGetDisplayColorBuffer_enc(void * self,uint32_t displayId,uint32_t * colorBuffer)1653 int rcGetDisplayColorBuffer_enc(void *self , uint32_t displayId, uint32_t* colorBuffer)
1654 {
1655 ENCODER_DEBUG_LOG("rcGetDisplayColorBuffer(displayId:0x%08x, colorBuffer:0x%08x)", displayId, colorBuffer);
1656 AEMU_SCOPED_TRACE("rcGetDisplayColorBuffer encode");
1657
1658 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1659 IOStream *stream = ctx->m_stream;
1660 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1661 bool useChecksum = checksumCalculator->getVersion() > 0;
1662
1663 const unsigned int __size_colorBuffer = sizeof(uint32_t);
1664 unsigned char *ptr;
1665 unsigned char *buf;
1666 const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
1667 const size_t checksumSize = checksumCalculator->checksumByteSize();
1668 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1669 buf = stream->alloc(totalSize);
1670 ptr = buf;
1671 int tmp = OP_rcGetDisplayColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
1672 memcpy(ptr, &totalSize, 4); ptr += 4;
1673
1674 memcpy(ptr, &displayId, 4); ptr += 4;
1675 memcpy(ptr, &__size_colorBuffer, 4); ptr += 4;
1676
1677 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1678 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1679
1680 stream->readback(colorBuffer, __size_colorBuffer);
1681 if (useChecksum) checksumCalculator->addBuffer(colorBuffer, __size_colorBuffer);
1682
1683 int retval;
1684 stream->readback(&retval, 4);
1685 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1686 if (useChecksum) {
1687 unsigned char *checksumBufPtr = NULL;
1688 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1689 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1690 stream->readback(checksumBufPtr, checksumSize);
1691 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1692 ALOGE("rcGetDisplayColorBuffer: GL communication error, please report this issue to b.android.com.\n");
1693 abort();
1694 }
1695 }
1696 return retval;
1697 }
1698
rcGetColorBufferDisplay_enc(void * self,uint32_t colorBuffer,uint32_t * displayId)1699 int rcGetColorBufferDisplay_enc(void *self , uint32_t colorBuffer, uint32_t* displayId)
1700 {
1701 ENCODER_DEBUG_LOG("rcGetColorBufferDisplay(colorBuffer:0x%08x, displayId:0x%08x)", colorBuffer, displayId);
1702 AEMU_SCOPED_TRACE("rcGetColorBufferDisplay encode");
1703
1704 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1705 IOStream *stream = ctx->m_stream;
1706 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1707 bool useChecksum = checksumCalculator->getVersion() > 0;
1708
1709 const unsigned int __size_displayId = sizeof(uint32_t);
1710 unsigned char *ptr;
1711 unsigned char *buf;
1712 const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
1713 const size_t checksumSize = checksumCalculator->checksumByteSize();
1714 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1715 buf = stream->alloc(totalSize);
1716 ptr = buf;
1717 int tmp = OP_rcGetColorBufferDisplay;memcpy(ptr, &tmp, 4); ptr += 4;
1718 memcpy(ptr, &totalSize, 4); ptr += 4;
1719
1720 memcpy(ptr, &colorBuffer, 4); ptr += 4;
1721 memcpy(ptr, &__size_displayId, 4); ptr += 4;
1722
1723 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1724 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1725
1726 stream->readback(displayId, __size_displayId);
1727 if (useChecksum) checksumCalculator->addBuffer(displayId, __size_displayId);
1728
1729 int retval;
1730 stream->readback(&retval, 4);
1731 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1732 if (useChecksum) {
1733 unsigned char *checksumBufPtr = NULL;
1734 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1735 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1736 stream->readback(checksumBufPtr, checksumSize);
1737 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1738 ALOGE("rcGetColorBufferDisplay: GL communication error, please report this issue to b.android.com.\n");
1739 abort();
1740 }
1741 }
1742 return retval;
1743 }
1744
rcGetDisplayPose_enc(void * self,uint32_t displayId,GLint * x,GLint * y,uint32_t * w,uint32_t * h)1745 int rcGetDisplayPose_enc(void *self , uint32_t displayId, GLint* x, GLint* y, uint32_t* w, uint32_t* h)
1746 {
1747 ENCODER_DEBUG_LOG("rcGetDisplayPose(displayId:0x%08x, x:0x%08x, y:0x%08x, w:0x%08x, h:0x%08x)", displayId, x, y, w, h);
1748 AEMU_SCOPED_TRACE("rcGetDisplayPose encode");
1749
1750 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1751 IOStream *stream = ctx->m_stream;
1752 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1753 bool useChecksum = checksumCalculator->getVersion() > 0;
1754
1755 const unsigned int __size_x = sizeof(int32_t);
1756 const unsigned int __size_y = sizeof(int32_t);
1757 const unsigned int __size_w = sizeof(uint32_t);
1758 const unsigned int __size_h = sizeof(uint32_t);
1759 unsigned char *ptr;
1760 unsigned char *buf;
1761 const size_t sizeWithoutChecksum = 8 + 4 + 0 + 0 + 0 + 0 + 4*4;
1762 const size_t checksumSize = checksumCalculator->checksumByteSize();
1763 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1764 buf = stream->alloc(totalSize);
1765 ptr = buf;
1766 int tmp = OP_rcGetDisplayPose;memcpy(ptr, &tmp, 4); ptr += 4;
1767 memcpy(ptr, &totalSize, 4); ptr += 4;
1768
1769 memcpy(ptr, &displayId, 4); ptr += 4;
1770 memcpy(ptr, &__size_x, 4); ptr += 4;
1771 memcpy(ptr, &__size_y, 4); ptr += 4;
1772 memcpy(ptr, &__size_w, 4); ptr += 4;
1773 memcpy(ptr, &__size_h, 4); ptr += 4;
1774
1775 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1776 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1777
1778 stream->readback(x, __size_x);
1779 if (useChecksum) checksumCalculator->addBuffer(x, __size_x);
1780 stream->readback(y, __size_y);
1781 if (useChecksum) checksumCalculator->addBuffer(y, __size_y);
1782 stream->readback(w, __size_w);
1783 if (useChecksum) checksumCalculator->addBuffer(w, __size_w);
1784 stream->readback(h, __size_h);
1785 if (useChecksum) checksumCalculator->addBuffer(h, __size_h);
1786
1787 int retval;
1788 stream->readback(&retval, 4);
1789 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1790 if (useChecksum) {
1791 unsigned char *checksumBufPtr = NULL;
1792 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1793 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1794 stream->readback(checksumBufPtr, checksumSize);
1795 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1796 ALOGE("rcGetDisplayPose: GL communication error, please report this issue to b.android.com.\n");
1797 abort();
1798 }
1799 }
1800 return retval;
1801 }
1802
rcSetDisplayPose_enc(void * self,uint32_t displayId,GLint x,GLint y,uint32_t w,uint32_t h)1803 int rcSetDisplayPose_enc(void *self , uint32_t displayId, GLint x, GLint y, uint32_t w, uint32_t h)
1804 {
1805 ENCODER_DEBUG_LOG("rcSetDisplayPose(displayId:0x%08x, x:0x%08x, y:0x%08x, w:0x%08x, h:0x%08x)", displayId, x, y, w, h);
1806 AEMU_SCOPED_TRACE("rcSetDisplayPose encode");
1807
1808 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1809 IOStream *stream = ctx->m_stream;
1810 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1811 bool useChecksum = checksumCalculator->getVersion() > 0;
1812
1813 unsigned char *ptr;
1814 unsigned char *buf;
1815 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
1816 const size_t checksumSize = checksumCalculator->checksumByteSize();
1817 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1818 buf = stream->alloc(totalSize);
1819 ptr = buf;
1820 int tmp = OP_rcSetDisplayPose;memcpy(ptr, &tmp, 4); ptr += 4;
1821 memcpy(ptr, &totalSize, 4); ptr += 4;
1822
1823 memcpy(ptr, &displayId, 4); ptr += 4;
1824 memcpy(ptr, &x, 4); ptr += 4;
1825 memcpy(ptr, &y, 4); ptr += 4;
1826 memcpy(ptr, &w, 4); ptr += 4;
1827 memcpy(ptr, &h, 4); ptr += 4;
1828
1829 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1830 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1831
1832
1833 int retval;
1834 stream->readback(&retval, 4);
1835 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1836 if (useChecksum) {
1837 unsigned char *checksumBufPtr = NULL;
1838 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1839 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1840 stream->readback(checksumBufPtr, checksumSize);
1841 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1842 ALOGE("rcSetDisplayPose: GL communication error, please report this issue to b.android.com.\n");
1843 abort();
1844 }
1845 }
1846 return retval;
1847 }
1848
rcSetColorBufferVulkanMode_enc(void * self,uint32_t colorBuffer,uint32_t mode)1849 GLint rcSetColorBufferVulkanMode_enc(void *self , uint32_t colorBuffer, uint32_t mode)
1850 {
1851 ENCODER_DEBUG_LOG("rcSetColorBufferVulkanMode(colorBuffer:0x%08x, mode:0x%08x)", colorBuffer, mode);
1852 AEMU_SCOPED_TRACE("rcSetColorBufferVulkanMode encode");
1853
1854 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1855 IOStream *stream = ctx->m_stream;
1856 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1857 bool useChecksum = checksumCalculator->getVersion() > 0;
1858
1859 unsigned char *ptr;
1860 unsigned char *buf;
1861 const size_t sizeWithoutChecksum = 8 + 4 + 4;
1862 const size_t checksumSize = checksumCalculator->checksumByteSize();
1863 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1864 buf = stream->alloc(totalSize);
1865 ptr = buf;
1866 int tmp = OP_rcSetColorBufferVulkanMode;memcpy(ptr, &tmp, 4); ptr += 4;
1867 memcpy(ptr, &totalSize, 4); ptr += 4;
1868
1869 memcpy(ptr, &colorBuffer, 4); ptr += 4;
1870 memcpy(ptr, &mode, 4); ptr += 4;
1871
1872 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1873 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1874
1875
1876 GLint retval;
1877 stream->readback(&retval, 4);
1878 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1879 if (useChecksum) {
1880 unsigned char *checksumBufPtr = NULL;
1881 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1882 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1883 stream->readback(checksumBufPtr, checksumSize);
1884 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1885 ALOGE("rcSetColorBufferVulkanMode: GL communication error, please report this issue to b.android.com.\n");
1886 abort();
1887 }
1888 }
1889 return retval;
1890 }
1891
rcReadColorBufferYUV_enc(void * self,uint32_t colorbuffer,GLint x,GLint y,GLint width,GLint height,void * pixels,uint32_t pixels_size)1892 void rcReadColorBufferYUV_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, void* pixels, uint32_t pixels_size)
1893 {
1894 ENCODER_DEBUG_LOG("rcReadColorBufferYUV(colorbuffer:0x%08x, x:0x%08x, y:0x%08x, width:0x%08x, height:0x%08x, pixels:0x%08x, pixels_size:0x%08x)", colorbuffer, x, y, width, height, pixels, pixels_size);
1895 AEMU_SCOPED_TRACE("rcReadColorBufferYUV encode");
1896
1897 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1898 IOStream *stream = ctx->m_stream;
1899 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1900 bool useChecksum = checksumCalculator->getVersion() > 0;
1901
1902 const unsigned int __size_pixels = pixels_size;
1903 unsigned char *ptr;
1904 unsigned char *buf;
1905 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 0 + 4 + 1*4;
1906 const size_t checksumSize = checksumCalculator->checksumByteSize();
1907 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1908 buf = stream->alloc(totalSize);
1909 ptr = buf;
1910 int tmp = OP_rcReadColorBufferYUV;memcpy(ptr, &tmp, 4); ptr += 4;
1911 memcpy(ptr, &totalSize, 4); ptr += 4;
1912
1913 memcpy(ptr, &colorbuffer, 4); ptr += 4;
1914 memcpy(ptr, &x, 4); ptr += 4;
1915 memcpy(ptr, &y, 4); ptr += 4;
1916 memcpy(ptr, &width, 4); ptr += 4;
1917 memcpy(ptr, &height, 4); ptr += 4;
1918 memcpy(ptr, &__size_pixels, 4); ptr += 4;
1919 memcpy(ptr, &pixels_size, 4); ptr += 4;
1920
1921 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1922 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1923
1924 stream->readback(pixels, __size_pixels);
1925 if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
1926 if (useChecksum) {
1927 unsigned char *checksumBufPtr = NULL;
1928 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1929 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1930 stream->readback(checksumBufPtr, checksumSize);
1931 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1932 ALOGE("rcReadColorBufferYUV: GL communication error, please report this issue to b.android.com.\n");
1933 abort();
1934 }
1935 }
1936 }
1937
rcIsSyncSignaled_enc(void * self,uint64_t sync)1938 int rcIsSyncSignaled_enc(void *self , uint64_t sync)
1939 {
1940 ENCODER_DEBUG_LOG("rcIsSyncSignaled(sync:0x%016lx)", sync);
1941 AEMU_SCOPED_TRACE("rcIsSyncSignaled encode");
1942
1943 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1944 IOStream *stream = ctx->m_stream;
1945 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1946 bool useChecksum = checksumCalculator->getVersion() > 0;
1947
1948 unsigned char *ptr;
1949 unsigned char *buf;
1950 const size_t sizeWithoutChecksum = 8 + 8;
1951 const size_t checksumSize = checksumCalculator->checksumByteSize();
1952 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1953 buf = stream->alloc(totalSize);
1954 ptr = buf;
1955 int tmp = OP_rcIsSyncSignaled;memcpy(ptr, &tmp, 4); ptr += 4;
1956 memcpy(ptr, &totalSize, 4); ptr += 4;
1957
1958 memcpy(ptr, &sync, 8); ptr += 8;
1959
1960 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1961 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1962
1963
1964 int retval;
1965 stream->readback(&retval, 4);
1966 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1967 if (useChecksum) {
1968 unsigned char *checksumBufPtr = NULL;
1969 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
1970 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1971 stream->readback(checksumBufPtr, checksumSize);
1972 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1973 ALOGE("rcIsSyncSignaled: GL communication error, please report this issue to b.android.com.\n");
1974 abort();
1975 }
1976 }
1977 return retval;
1978 }
1979
rcCreateColorBufferWithHandle_enc(void * self,uint32_t width,uint32_t height,GLenum internalFormat,uint32_t handle)1980 void rcCreateColorBufferWithHandle_enc(void *self , uint32_t width, uint32_t height, GLenum internalFormat, uint32_t handle)
1981 {
1982 ENCODER_DEBUG_LOG("rcCreateColorBufferWithHandle(width:0x%08x, height:0x%08x, internalFormat:0x%08x, handle:0x%08x)", width, height, internalFormat, handle);
1983 AEMU_SCOPED_TRACE("rcCreateColorBufferWithHandle encode");
1984
1985 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1986 IOStream *stream = ctx->m_stream;
1987 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1988 bool useChecksum = checksumCalculator->getVersion() > 0;
1989
1990 unsigned char *ptr;
1991 unsigned char *buf;
1992 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
1993 const size_t checksumSize = checksumCalculator->checksumByteSize();
1994 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1995 buf = stream->alloc(totalSize);
1996 ptr = buf;
1997 int tmp = OP_rcCreateColorBufferWithHandle;memcpy(ptr, &tmp, 4); ptr += 4;
1998 memcpy(ptr, &totalSize, 4); ptr += 4;
1999
2000 memcpy(ptr, &width, 4); ptr += 4;
2001 memcpy(ptr, &height, 4); ptr += 4;
2002 memcpy(ptr, &internalFormat, 4); ptr += 4;
2003 memcpy(ptr, &handle, 4); ptr += 4;
2004
2005 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2006 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2007
2008 }
2009
rcCreateBuffer_enc(void * self,uint32_t size)2010 uint32_t rcCreateBuffer_enc(void *self , uint32_t size)
2011 {
2012 ENCODER_DEBUG_LOG("rcCreateBuffer(size:0x%08x)", size);
2013 AEMU_SCOPED_TRACE("rcCreateBuffer encode");
2014
2015 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2016 IOStream *stream = ctx->m_stream;
2017 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2018 bool useChecksum = checksumCalculator->getVersion() > 0;
2019
2020 unsigned char *ptr;
2021 unsigned char *buf;
2022 const size_t sizeWithoutChecksum = 8 + 4;
2023 const size_t checksumSize = checksumCalculator->checksumByteSize();
2024 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2025 buf = stream->alloc(totalSize);
2026 ptr = buf;
2027 int tmp = OP_rcCreateBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
2028 memcpy(ptr, &totalSize, 4); ptr += 4;
2029
2030 memcpy(ptr, &size, 4); ptr += 4;
2031
2032 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2033 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2034
2035
2036 uint32_t retval;
2037 stream->readback(&retval, 4);
2038 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2039 if (useChecksum) {
2040 unsigned char *checksumBufPtr = NULL;
2041 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2042 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2043 stream->readback(checksumBufPtr, checksumSize);
2044 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2045 ALOGE("rcCreateBuffer: GL communication error, please report this issue to b.android.com.\n");
2046 abort();
2047 }
2048 }
2049 return retval;
2050 }
2051
rcCloseBuffer_enc(void * self,uint32_t buffer)2052 void rcCloseBuffer_enc(void *self , uint32_t buffer)
2053 {
2054 ENCODER_DEBUG_LOG("rcCloseBuffer(buffer:0x%08x)", buffer);
2055 AEMU_SCOPED_TRACE("rcCloseBuffer encode");
2056
2057 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2058 IOStream *stream = ctx->m_stream;
2059 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2060 bool useChecksum = checksumCalculator->getVersion() > 0;
2061
2062 unsigned char *ptr;
2063 unsigned char *buf;
2064 const size_t sizeWithoutChecksum = 8 + 4;
2065 const size_t checksumSize = checksumCalculator->checksumByteSize();
2066 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2067 buf = stream->alloc(totalSize);
2068 ptr = buf;
2069 int tmp = OP_rcCloseBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
2070 memcpy(ptr, &totalSize, 4); ptr += 4;
2071
2072 memcpy(ptr, &buffer, 4); ptr += 4;
2073
2074 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2075 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2076
2077 }
2078
rcSetColorBufferVulkanMode2_enc(void * self,uint32_t colorBuffer,uint32_t mode,uint32_t memoryProperty)2079 GLint rcSetColorBufferVulkanMode2_enc(void *self , uint32_t colorBuffer, uint32_t mode, uint32_t memoryProperty)
2080 {
2081 ENCODER_DEBUG_LOG("rcSetColorBufferVulkanMode2(colorBuffer:0x%08x, mode:0x%08x, memoryProperty:0x%08x)", colorBuffer, mode, memoryProperty);
2082 AEMU_SCOPED_TRACE("rcSetColorBufferVulkanMode2 encode");
2083
2084 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2085 IOStream *stream = ctx->m_stream;
2086 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2087 bool useChecksum = checksumCalculator->getVersion() > 0;
2088
2089 unsigned char *ptr;
2090 unsigned char *buf;
2091 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
2092 const size_t checksumSize = checksumCalculator->checksumByteSize();
2093 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2094 buf = stream->alloc(totalSize);
2095 ptr = buf;
2096 int tmp = OP_rcSetColorBufferVulkanMode2;memcpy(ptr, &tmp, 4); ptr += 4;
2097 memcpy(ptr, &totalSize, 4); ptr += 4;
2098
2099 memcpy(ptr, &colorBuffer, 4); ptr += 4;
2100 memcpy(ptr, &mode, 4); ptr += 4;
2101 memcpy(ptr, &memoryProperty, 4); ptr += 4;
2102
2103 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2104 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2105
2106
2107 GLint retval;
2108 stream->readback(&retval, 4);
2109 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2110 if (useChecksum) {
2111 unsigned char *checksumBufPtr = NULL;
2112 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2113 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2114 stream->readback(checksumBufPtr, checksumSize);
2115 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2116 ALOGE("rcSetColorBufferVulkanMode2: GL communication error, please report this issue to b.android.com.\n");
2117 abort();
2118 }
2119 }
2120 return retval;
2121 }
2122
rcMapGpaToBufferHandle_enc(void * self,uint32_t bufferHandle,uint64_t gpa)2123 int rcMapGpaToBufferHandle_enc(void *self , uint32_t bufferHandle, uint64_t gpa)
2124 {
2125 ENCODER_DEBUG_LOG("rcMapGpaToBufferHandle(bufferHandle:0x%08x, gpa:0x%016lx)", bufferHandle, gpa);
2126 AEMU_SCOPED_TRACE("rcMapGpaToBufferHandle encode");
2127
2128 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2129 IOStream *stream = ctx->m_stream;
2130 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2131 bool useChecksum = checksumCalculator->getVersion() > 0;
2132
2133 unsigned char *ptr;
2134 unsigned char *buf;
2135 const size_t sizeWithoutChecksum = 8 + 4 + 8;
2136 const size_t checksumSize = checksumCalculator->checksumByteSize();
2137 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2138 buf = stream->alloc(totalSize);
2139 ptr = buf;
2140 int tmp = OP_rcMapGpaToBufferHandle;memcpy(ptr, &tmp, 4); ptr += 4;
2141 memcpy(ptr, &totalSize, 4); ptr += 4;
2142
2143 memcpy(ptr, &bufferHandle, 4); ptr += 4;
2144 memcpy(ptr, &gpa, 8); ptr += 8;
2145
2146 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2147 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2148
2149
2150 int retval;
2151 stream->readback(&retval, 4);
2152 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2153 if (useChecksum) {
2154 unsigned char *checksumBufPtr = NULL;
2155 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2156 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2157 stream->readback(checksumBufPtr, checksumSize);
2158 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2159 ALOGE("rcMapGpaToBufferHandle: GL communication error, please report this issue to b.android.com.\n");
2160 abort();
2161 }
2162 }
2163 return retval;
2164 }
2165
rcCreateBuffer2_enc(void * self,uint64_t size,uint32_t memoryProperty)2166 uint32_t rcCreateBuffer2_enc(void *self , uint64_t size, uint32_t memoryProperty)
2167 {
2168 ENCODER_DEBUG_LOG("rcCreateBuffer2(size:0x%016lx, memoryProperty:0x%08x)", size, memoryProperty);
2169 AEMU_SCOPED_TRACE("rcCreateBuffer2 encode");
2170
2171 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2172 IOStream *stream = ctx->m_stream;
2173 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2174 bool useChecksum = checksumCalculator->getVersion() > 0;
2175
2176 unsigned char *ptr;
2177 unsigned char *buf;
2178 const size_t sizeWithoutChecksum = 8 + 8 + 4;
2179 const size_t checksumSize = checksumCalculator->checksumByteSize();
2180 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2181 buf = stream->alloc(totalSize);
2182 ptr = buf;
2183 int tmp = OP_rcCreateBuffer2;memcpy(ptr, &tmp, 4); ptr += 4;
2184 memcpy(ptr, &totalSize, 4); ptr += 4;
2185
2186 memcpy(ptr, &size, 8); ptr += 8;
2187 memcpy(ptr, &memoryProperty, 4); ptr += 4;
2188
2189 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2190 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2191
2192
2193 uint32_t retval;
2194 stream->readback(&retval, 4);
2195 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2196 if (useChecksum) {
2197 unsigned char *checksumBufPtr = NULL;
2198 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2199 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2200 stream->readback(checksumBufPtr, checksumSize);
2201 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2202 ALOGE("rcCreateBuffer2: GL communication error, please report this issue to b.android.com.\n");
2203 abort();
2204 }
2205 }
2206 return retval;
2207 }
2208
rcMapGpaToBufferHandle2_enc(void * self,uint32_t bufferHandle,uint64_t gpa,uint64_t size)2209 int rcMapGpaToBufferHandle2_enc(void *self , uint32_t bufferHandle, uint64_t gpa, uint64_t size)
2210 {
2211 ENCODER_DEBUG_LOG("rcMapGpaToBufferHandle2(bufferHandle:0x%08x, gpa:0x%016lx, size:0x%016lx)", bufferHandle, gpa, size);
2212 AEMU_SCOPED_TRACE("rcMapGpaToBufferHandle2 encode");
2213
2214 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2215 IOStream *stream = ctx->m_stream;
2216 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2217 bool useChecksum = checksumCalculator->getVersion() > 0;
2218
2219 unsigned char *ptr;
2220 unsigned char *buf;
2221 const size_t sizeWithoutChecksum = 8 + 4 + 8 + 8;
2222 const size_t checksumSize = checksumCalculator->checksumByteSize();
2223 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2224 buf = stream->alloc(totalSize);
2225 ptr = buf;
2226 int tmp = OP_rcMapGpaToBufferHandle2;memcpy(ptr, &tmp, 4); ptr += 4;
2227 memcpy(ptr, &totalSize, 4); ptr += 4;
2228
2229 memcpy(ptr, &bufferHandle, 4); ptr += 4;
2230 memcpy(ptr, &gpa, 8); ptr += 8;
2231 memcpy(ptr, &size, 8); ptr += 8;
2232
2233 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2234 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2235
2236
2237 int retval;
2238 stream->readback(&retval, 4);
2239 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2240 if (useChecksum) {
2241 unsigned char *checksumBufPtr = NULL;
2242 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2243 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2244 stream->readback(checksumBufPtr, checksumSize);
2245 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2246 ALOGE("rcMapGpaToBufferHandle2: GL communication error, please report this issue to b.android.com.\n");
2247 abort();
2248 }
2249 }
2250 return retval;
2251 }
2252
rcFlushWindowColorBufferAsyncWithFrameNumber_enc(void * self,uint32_t windowSurface,uint32_t frameNumber)2253 void rcFlushWindowColorBufferAsyncWithFrameNumber_enc(void *self , uint32_t windowSurface, uint32_t frameNumber)
2254 {
2255 ENCODER_DEBUG_LOG("rcFlushWindowColorBufferAsyncWithFrameNumber(windowSurface:0x%08x, frameNumber:0x%08x)", windowSurface, frameNumber);
2256 AEMU_SCOPED_TRACE("rcFlushWindowColorBufferAsyncWithFrameNumber encode");
2257
2258 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2259 IOStream *stream = ctx->m_stream;
2260 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2261 bool useChecksum = checksumCalculator->getVersion() > 0;
2262
2263 unsigned char *ptr;
2264 unsigned char *buf;
2265 const size_t sizeWithoutChecksum = 8 + 4 + 4;
2266 const size_t checksumSize = checksumCalculator->checksumByteSize();
2267 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2268 buf = stream->alloc(totalSize);
2269 ptr = buf;
2270 int tmp = OP_rcFlushWindowColorBufferAsyncWithFrameNumber;memcpy(ptr, &tmp, 4); ptr += 4;
2271 memcpy(ptr, &totalSize, 4); ptr += 4;
2272
2273 memcpy(ptr, &windowSurface, 4); ptr += 4;
2274 memcpy(ptr, &frameNumber, 4); ptr += 4;
2275
2276 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2277 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2278
2279 }
2280
rcSetTracingForPuid_enc(void * self,uint64_t puid,uint32_t enable,uint64_t guestTime)2281 void rcSetTracingForPuid_enc(void *self , uint64_t puid, uint32_t enable, uint64_t guestTime)
2282 {
2283 ENCODER_DEBUG_LOG("rcSetTracingForPuid(puid:0x%016lx, enable:0x%08x, guestTime:0x%016lx)", puid, enable, guestTime);
2284 AEMU_SCOPED_TRACE("rcSetTracingForPuid encode");
2285
2286 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2287 IOStream *stream = ctx->m_stream;
2288 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2289 bool useChecksum = checksumCalculator->getVersion() > 0;
2290
2291 unsigned char *ptr;
2292 unsigned char *buf;
2293 const size_t sizeWithoutChecksum = 8 + 8 + 4 + 8;
2294 const size_t checksumSize = checksumCalculator->checksumByteSize();
2295 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2296 buf = stream->alloc(totalSize);
2297 ptr = buf;
2298 int tmp = OP_rcSetTracingForPuid;memcpy(ptr, &tmp, 4); ptr += 4;
2299 memcpy(ptr, &totalSize, 4); ptr += 4;
2300
2301 memcpy(ptr, &puid, 8); ptr += 8;
2302 memcpy(ptr, &enable, 4); ptr += 4;
2303 memcpy(ptr, &guestTime, 8); ptr += 8;
2304
2305 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2306 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2307
2308 }
2309
rcMakeCurrentAsync_enc(void * self,uint32_t context,uint32_t drawSurf,uint32_t readSurf)2310 void rcMakeCurrentAsync_enc(void *self , uint32_t context, uint32_t drawSurf, uint32_t readSurf)
2311 {
2312 ENCODER_DEBUG_LOG("rcMakeCurrentAsync(context:0x%08x, drawSurf:0x%08x, readSurf:0x%08x)", context, drawSurf, readSurf);
2313 AEMU_SCOPED_TRACE("rcMakeCurrentAsync encode");
2314
2315 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2316 IOStream *stream = ctx->m_stream;
2317 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2318 bool useChecksum = checksumCalculator->getVersion() > 0;
2319
2320 unsigned char *ptr;
2321 unsigned char *buf;
2322 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
2323 const size_t checksumSize = checksumCalculator->checksumByteSize();
2324 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2325 buf = stream->alloc(totalSize);
2326 ptr = buf;
2327 int tmp = OP_rcMakeCurrentAsync;memcpy(ptr, &tmp, 4); ptr += 4;
2328 memcpy(ptr, &totalSize, 4); ptr += 4;
2329
2330 memcpy(ptr, &context, 4); ptr += 4;
2331 memcpy(ptr, &drawSurf, 4); ptr += 4;
2332 memcpy(ptr, &readSurf, 4); ptr += 4;
2333
2334 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2335 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2336
2337 stream->flush();
2338 }
2339
rcComposeAsync_enc(void * self,uint32_t bufferSize,void * buffer)2340 void rcComposeAsync_enc(void *self , uint32_t bufferSize, void* buffer)
2341 {
2342 ENCODER_DEBUG_LOG("rcComposeAsync(bufferSize:0x%08x, buffer:0x%08x)", bufferSize, buffer);
2343 AEMU_SCOPED_TRACE("rcComposeAsync encode");
2344
2345 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2346 IOStream *stream = ctx->m_stream;
2347 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2348 bool useChecksum = checksumCalculator->getVersion() > 0;
2349
2350 const unsigned int __size_buffer = bufferSize;
2351 unsigned char *ptr;
2352 unsigned char *buf;
2353 const size_t sizeWithoutChecksum = 8 + 4 + __size_buffer + 1*4;
2354 const size_t checksumSize = checksumCalculator->checksumByteSize();
2355 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2356 buf = stream->alloc(totalSize);
2357 ptr = buf;
2358 int tmp = OP_rcComposeAsync;memcpy(ptr, &tmp, 4); ptr += 4;
2359 memcpy(ptr, &totalSize, 4); ptr += 4;
2360
2361 memcpy(ptr, &bufferSize, 4); ptr += 4;
2362 memcpy(ptr, &__size_buffer, 4); ptr += 4;
2363 memcpy(ptr, buffer, __size_buffer);ptr += __size_buffer;
2364
2365 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2366 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2367
2368 stream->flush();
2369 }
2370
rcDestroySyncKHRAsync_enc(void * self,uint64_t sync)2371 void rcDestroySyncKHRAsync_enc(void *self , uint64_t sync)
2372 {
2373 ENCODER_DEBUG_LOG("rcDestroySyncKHRAsync(sync:0x%016lx)", sync);
2374 AEMU_SCOPED_TRACE("rcDestroySyncKHRAsync encode");
2375
2376 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2377 IOStream *stream = ctx->m_stream;
2378 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2379 bool useChecksum = checksumCalculator->getVersion() > 0;
2380
2381 unsigned char *ptr;
2382 unsigned char *buf;
2383 const size_t sizeWithoutChecksum = 8 + 8;
2384 const size_t checksumSize = checksumCalculator->checksumByteSize();
2385 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2386 buf = stream->alloc(totalSize);
2387 ptr = buf;
2388 int tmp = OP_rcDestroySyncKHRAsync;memcpy(ptr, &tmp, 4); ptr += 4;
2389 memcpy(ptr, &totalSize, 4); ptr += 4;
2390
2391 memcpy(ptr, &sync, 8); ptr += 8;
2392
2393 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2394 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2395
2396 stream->flush();
2397 }
2398
rcComposeWithoutPost_enc(void * self,uint32_t bufferSize,void * buffer)2399 GLint rcComposeWithoutPost_enc(void *self , uint32_t bufferSize, void* buffer)
2400 {
2401 ENCODER_DEBUG_LOG("rcComposeWithoutPost(bufferSize:0x%08x, buffer:0x%08x)", bufferSize, buffer);
2402 AEMU_SCOPED_TRACE("rcComposeWithoutPost encode");
2403
2404 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2405 IOStream *stream = ctx->m_stream;
2406 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2407 bool useChecksum = checksumCalculator->getVersion() > 0;
2408
2409 const unsigned int __size_buffer = bufferSize;
2410 unsigned char *ptr;
2411 unsigned char *buf;
2412 const size_t sizeWithoutChecksum = 8 + 4 + __size_buffer + 1*4;
2413 const size_t checksumSize = checksumCalculator->checksumByteSize();
2414 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2415 buf = stream->alloc(totalSize);
2416 ptr = buf;
2417 int tmp = OP_rcComposeWithoutPost;memcpy(ptr, &tmp, 4); ptr += 4;
2418 memcpy(ptr, &totalSize, 4); ptr += 4;
2419
2420 memcpy(ptr, &bufferSize, 4); ptr += 4;
2421 memcpy(ptr, &__size_buffer, 4); ptr += 4;
2422 memcpy(ptr, buffer, __size_buffer);ptr += __size_buffer;
2423
2424 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2425 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2426
2427
2428 GLint retval;
2429 stream->readback(&retval, 4);
2430 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2431 if (useChecksum) {
2432 unsigned char *checksumBufPtr = NULL;
2433 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2434 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2435 stream->readback(checksumBufPtr, checksumSize);
2436 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2437 ALOGE("rcComposeWithoutPost: GL communication error, please report this issue to b.android.com.\n");
2438 abort();
2439 }
2440 }
2441 return retval;
2442 }
2443
rcComposeAsyncWithoutPost_enc(void * self,uint32_t bufferSize,void * buffer)2444 void rcComposeAsyncWithoutPost_enc(void *self , uint32_t bufferSize, void* buffer)
2445 {
2446 ENCODER_DEBUG_LOG("rcComposeAsyncWithoutPost(bufferSize:0x%08x, buffer:0x%08x)", bufferSize, buffer);
2447 AEMU_SCOPED_TRACE("rcComposeAsyncWithoutPost encode");
2448
2449 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2450 IOStream *stream = ctx->m_stream;
2451 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2452 bool useChecksum = checksumCalculator->getVersion() > 0;
2453
2454 const unsigned int __size_buffer = bufferSize;
2455 unsigned char *ptr;
2456 unsigned char *buf;
2457 const size_t sizeWithoutChecksum = 8 + 4 + __size_buffer + 1*4;
2458 const size_t checksumSize = checksumCalculator->checksumByteSize();
2459 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2460 buf = stream->alloc(totalSize);
2461 ptr = buf;
2462 int tmp = OP_rcComposeAsyncWithoutPost;memcpy(ptr, &tmp, 4); ptr += 4;
2463 memcpy(ptr, &totalSize, 4); ptr += 4;
2464
2465 memcpy(ptr, &bufferSize, 4); ptr += 4;
2466 memcpy(ptr, &__size_buffer, 4); ptr += 4;
2467 memcpy(ptr, buffer, __size_buffer);ptr += __size_buffer;
2468
2469 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2470 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2471
2472 stream->flush();
2473 }
2474
rcCreateDisplayById_enc(void * self,uint32_t displayId)2475 int rcCreateDisplayById_enc(void *self , uint32_t displayId)
2476 {
2477 ENCODER_DEBUG_LOG("rcCreateDisplayById(displayId:0x%08x)", displayId);
2478 AEMU_SCOPED_TRACE("rcCreateDisplayById encode");
2479
2480 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2481 IOStream *stream = ctx->m_stream;
2482 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2483 bool useChecksum = checksumCalculator->getVersion() > 0;
2484
2485 unsigned char *ptr;
2486 unsigned char *buf;
2487 const size_t sizeWithoutChecksum = 8 + 4;
2488 const size_t checksumSize = checksumCalculator->checksumByteSize();
2489 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2490 buf = stream->alloc(totalSize);
2491 ptr = buf;
2492 int tmp = OP_rcCreateDisplayById;memcpy(ptr, &tmp, 4); ptr += 4;
2493 memcpy(ptr, &totalSize, 4); ptr += 4;
2494
2495 memcpy(ptr, &displayId, 4); ptr += 4;
2496
2497 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2498 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2499
2500
2501 int retval;
2502 stream->readback(&retval, 4);
2503 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2504 if (useChecksum) {
2505 unsigned char *checksumBufPtr = NULL;
2506 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2507 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2508 stream->readback(checksumBufPtr, checksumSize);
2509 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2510 ALOGE("rcCreateDisplayById: GL communication error, please report this issue to b.android.com.\n");
2511 abort();
2512 }
2513 }
2514 return retval;
2515 }
2516
rcSetDisplayPoseDpi_enc(void * self,uint32_t displayId,GLint x,GLint y,uint32_t w,uint32_t h,uint32_t dpi)2517 int rcSetDisplayPoseDpi_enc(void *self , uint32_t displayId, GLint x, GLint y, uint32_t w, uint32_t h, uint32_t dpi)
2518 {
2519 ENCODER_DEBUG_LOG("rcSetDisplayPoseDpi(displayId:0x%08x, x:0x%08x, y:0x%08x, w:0x%08x, h:0x%08x, dpi:0x%08x)", displayId, x, y, w, h, dpi);
2520 AEMU_SCOPED_TRACE("rcSetDisplayPoseDpi encode");
2521
2522 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2523 IOStream *stream = ctx->m_stream;
2524 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2525 bool useChecksum = checksumCalculator->getVersion() > 0;
2526
2527 unsigned char *ptr;
2528 unsigned char *buf;
2529 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4;
2530 const size_t checksumSize = checksumCalculator->checksumByteSize();
2531 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2532 buf = stream->alloc(totalSize);
2533 ptr = buf;
2534 int tmp = OP_rcSetDisplayPoseDpi;memcpy(ptr, &tmp, 4); ptr += 4;
2535 memcpy(ptr, &totalSize, 4); ptr += 4;
2536
2537 memcpy(ptr, &displayId, 4); ptr += 4;
2538 memcpy(ptr, &x, 4); ptr += 4;
2539 memcpy(ptr, &y, 4); ptr += 4;
2540 memcpy(ptr, &w, 4); ptr += 4;
2541 memcpy(ptr, &h, 4); ptr += 4;
2542 memcpy(ptr, &dpi, 4); ptr += 4;
2543
2544 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2545 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2546
2547
2548 int retval;
2549 stream->readback(&retval, 4);
2550 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2551 if (useChecksum) {
2552 unsigned char *checksumBufPtr = NULL;
2553 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2554 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2555 stream->readback(checksumBufPtr, checksumSize);
2556 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2557 ALOGE("rcSetDisplayPoseDpi: GL communication error, please report this issue to b.android.com.\n");
2558 abort();
2559 }
2560 }
2561 return retval;
2562 }
2563
rcReadColorBufferDMA_enc(void * self,uint32_t colorbuffer,GLint x,GLint y,GLint width,GLint height,GLenum format,GLenum type,void * pixels,uint32_t pixels_size)2564 int rcReadColorBufferDMA_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels, uint32_t pixels_size)
2565 {
2566 ENCODER_DEBUG_LOG("rcReadColorBufferDMA(colorbuffer:0x%08x, x:0x%08x, y:0x%08x, width:0x%08x, height:0x%08x, format:0x%08x, type:0x%08x, pixels:0x%08x, pixels_size:0x%08x)", colorbuffer, x, y, width, height, format, type, pixels, pixels_size);
2567 AEMU_SCOPED_TRACE("rcReadColorBufferDMA encode");
2568
2569 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2570 IOStream *stream = ctx->m_stream;
2571 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2572 bool useChecksum = checksumCalculator->getVersion() > 0;
2573
2574 const unsigned int __size_pixels = pixels_size;
2575 unsigned char *ptr;
2576 unsigned char *buf;
2577 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 8 + 4 + 1*4;
2578 const size_t checksumSize = checksumCalculator->checksumByteSize();
2579 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2580 buf = stream->alloc(totalSize);
2581 ptr = buf;
2582 int tmp = OP_rcReadColorBufferDMA;memcpy(ptr, &tmp, 4); ptr += 4;
2583 memcpy(ptr, &totalSize, 4); ptr += 4;
2584
2585 memcpy(ptr, &colorbuffer, 4); ptr += 4;
2586 memcpy(ptr, &x, 4); ptr += 4;
2587 memcpy(ptr, &y, 4); ptr += 4;
2588 memcpy(ptr, &width, 4); ptr += 4;
2589 memcpy(ptr, &height, 4); ptr += 4;
2590 memcpy(ptr, &format, 4); ptr += 4;
2591 memcpy(ptr, &type, 4); ptr += 4;
2592 *(uint64_t *)(ptr) = ctx->lockAndWriteDma(pixels, __size_pixels); ptr += 8;
2593 memcpy(ptr, &pixels_size, 4); ptr += 4;
2594
2595 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2596 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2597
2598 // Skip readback for var pixels as it's DMA
2599 // Skip checksum for var pixels as it's DMA
2600
2601 int retval;
2602 stream->readback(&retval, 4);
2603 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2604 if (useChecksum) {
2605 unsigned char *checksumBufPtr = NULL;
2606 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2607 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2608 stream->readback(checksumBufPtr, checksumSize);
2609 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2610 ALOGE("rcReadColorBufferDMA: GL communication error, please report this issue to b.android.com.\n");
2611 abort();
2612 }
2613 }
2614 return retval;
2615 }
2616
rcGetFBDisplayConfigsCount_enc(void * self)2617 int rcGetFBDisplayConfigsCount_enc(void *self )
2618 {
2619 ENCODER_DEBUG_LOG("rcGetFBDisplayConfigsCount()");
2620 AEMU_SCOPED_TRACE("rcGetFBDisplayConfigsCount encode");
2621
2622 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2623 IOStream *stream = ctx->m_stream;
2624 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2625 bool useChecksum = checksumCalculator->getVersion() > 0;
2626
2627 unsigned char *ptr;
2628 unsigned char *buf;
2629 const size_t sizeWithoutChecksum = 8;
2630 const size_t checksumSize = checksumCalculator->checksumByteSize();
2631 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2632 buf = stream->alloc(totalSize);
2633 ptr = buf;
2634 int tmp = OP_rcGetFBDisplayConfigsCount;memcpy(ptr, &tmp, 4); ptr += 4;
2635 memcpy(ptr, &totalSize, 4); ptr += 4;
2636
2637
2638 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2639 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2640
2641
2642 int retval;
2643 stream->readback(&retval, 4);
2644 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2645 if (useChecksum) {
2646 unsigned char *checksumBufPtr = NULL;
2647 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2648 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2649 stream->readback(checksumBufPtr, checksumSize);
2650 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2651 ALOGE("rcGetFBDisplayConfigsCount: GL communication error, please report this issue to b.android.com.\n");
2652 abort();
2653 }
2654 }
2655 return retval;
2656 }
2657
rcGetFBDisplayConfigsParam_enc(void * self,int configId,EGLint param)2658 int rcGetFBDisplayConfigsParam_enc(void *self , int configId, EGLint param)
2659 {
2660 ENCODER_DEBUG_LOG("rcGetFBDisplayConfigsParam(configId:%d, param:0x%08x)", configId, param);
2661 AEMU_SCOPED_TRACE("rcGetFBDisplayConfigsParam encode");
2662
2663 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2664 IOStream *stream = ctx->m_stream;
2665 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2666 bool useChecksum = checksumCalculator->getVersion() > 0;
2667
2668 unsigned char *ptr;
2669 unsigned char *buf;
2670 const size_t sizeWithoutChecksum = 8 + 4 + 4;
2671 const size_t checksumSize = checksumCalculator->checksumByteSize();
2672 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2673 buf = stream->alloc(totalSize);
2674 ptr = buf;
2675 int tmp = OP_rcGetFBDisplayConfigsParam;memcpy(ptr, &tmp, 4); ptr += 4;
2676 memcpy(ptr, &totalSize, 4); ptr += 4;
2677
2678 memcpy(ptr, &configId, 4); ptr += 4;
2679 memcpy(ptr, ¶m, 4); ptr += 4;
2680
2681 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2682 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2683
2684
2685 int retval;
2686 stream->readback(&retval, 4);
2687 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2688 if (useChecksum) {
2689 unsigned char *checksumBufPtr = NULL;
2690 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2691 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2692 stream->readback(checksumBufPtr, checksumSize);
2693 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2694 ALOGE("rcGetFBDisplayConfigsParam: GL communication error, please report this issue to b.android.com.\n");
2695 abort();
2696 }
2697 }
2698 return retval;
2699 }
2700
rcGetFBDisplayActiveConfig_enc(void * self)2701 int rcGetFBDisplayActiveConfig_enc(void *self )
2702 {
2703 ENCODER_DEBUG_LOG("rcGetFBDisplayActiveConfig()");
2704 AEMU_SCOPED_TRACE("rcGetFBDisplayActiveConfig encode");
2705
2706 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2707 IOStream *stream = ctx->m_stream;
2708 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2709 bool useChecksum = checksumCalculator->getVersion() > 0;
2710
2711 unsigned char *ptr;
2712 unsigned char *buf;
2713 const size_t sizeWithoutChecksum = 8;
2714 const size_t checksumSize = checksumCalculator->checksumByteSize();
2715 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2716 buf = stream->alloc(totalSize);
2717 ptr = buf;
2718 int tmp = OP_rcGetFBDisplayActiveConfig;memcpy(ptr, &tmp, 4); ptr += 4;
2719 memcpy(ptr, &totalSize, 4); ptr += 4;
2720
2721
2722 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2723 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2724
2725
2726 int retval;
2727 stream->readback(&retval, 4);
2728 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2729 if (useChecksum) {
2730 unsigned char *checksumBufPtr = NULL;
2731 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2732 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2733 stream->readback(checksumBufPtr, checksumSize);
2734 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2735 ALOGE("rcGetFBDisplayActiveConfig: GL communication error, please report this issue to b.android.com.\n");
2736 abort();
2737 }
2738 }
2739 return retval;
2740 }
2741
rcSetProcessMetadata_enc(void * self,char * key,RenderControlByte * valuePtr,uint32_t valueSize)2742 void rcSetProcessMetadata_enc(void *self , char* key, RenderControlByte* valuePtr, uint32_t valueSize)
2743 {
2744 ENCODER_DEBUG_LOG("rcSetProcessMetadata(key:%s, valuePtr:%p, valueSize:0x%08x)", key, valuePtr, valueSize);
2745 AEMU_SCOPED_TRACE("rcSetProcessMetadata encode");
2746
2747 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2748 IOStream *stream = ctx->m_stream;
2749 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2750 bool useChecksum = checksumCalculator->getVersion() > 0;
2751
2752 const unsigned int __size_key = (strlen(key) + 1);
2753 const unsigned int __size_valuePtr = valueSize;
2754 unsigned char *ptr;
2755 unsigned char *buf;
2756 const size_t sizeWithoutChecksum = 8 + __size_key + __size_valuePtr + 4 + 2*4;
2757 const size_t checksumSize = checksumCalculator->checksumByteSize();
2758 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2759 buf = stream->alloc(totalSize);
2760 ptr = buf;
2761 int tmp = OP_rcSetProcessMetadata;memcpy(ptr, &tmp, 4); ptr += 4;
2762 memcpy(ptr, &totalSize, 4); ptr += 4;
2763
2764 memcpy(ptr, &__size_key, 4); ptr += 4;
2765 memcpy(ptr, key, __size_key);ptr += __size_key;
2766 memcpy(ptr, &__size_valuePtr, 4); ptr += 4;
2767 memcpy(ptr, valuePtr, __size_valuePtr);ptr += __size_valuePtr;
2768 memcpy(ptr, &valueSize, 4); ptr += 4;
2769
2770 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2771 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2772
2773 }
2774
rcGetHostExtensionsString_enc(void * self,uint32_t bufferSize,void * buffer)2775 int rcGetHostExtensionsString_enc(void *self , uint32_t bufferSize, void* buffer)
2776 {
2777 ENCODER_DEBUG_LOG("rcGetHostExtensionsString(bufferSize:0x%08x, buffer:0x%08x)", bufferSize, buffer);
2778 AEMU_SCOPED_TRACE("rcGetHostExtensionsString encode");
2779
2780 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
2781 IOStream *stream = ctx->m_stream;
2782 gfxstream::guest::ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2783 bool useChecksum = checksumCalculator->getVersion() > 0;
2784
2785 const unsigned int __size_buffer = bufferSize;
2786 unsigned char *ptr;
2787 unsigned char *buf;
2788 const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
2789 const size_t checksumSize = checksumCalculator->checksumByteSize();
2790 const size_t totalSize = sizeWithoutChecksum + checksumSize;
2791 buf = stream->alloc(totalSize);
2792 ptr = buf;
2793 int tmp = OP_rcGetHostExtensionsString;memcpy(ptr, &tmp, 4); ptr += 4;
2794 memcpy(ptr, &totalSize, 4); ptr += 4;
2795
2796 memcpy(ptr, &bufferSize, 4); ptr += 4;
2797 memcpy(ptr, &__size_buffer, 4); ptr += 4;
2798
2799 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2800 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2801
2802 stream->readback(buffer, __size_buffer);
2803 if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer);
2804
2805 int retval;
2806 stream->readback(&retval, 4);
2807 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2808 if (useChecksum) {
2809 unsigned char *checksumBufPtr = NULL;
2810 unsigned char checksumBuf[gfxstream::guest::ChecksumCalculator::kMaxChecksumSize];
2811 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2812 stream->readback(checksumBufPtr, checksumSize);
2813 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2814 ALOGE("rcGetHostExtensionsString: GL communication error, please report this issue to b.android.com.\n");
2815 abort();
2816 }
2817 }
2818 return retval;
2819 }
2820
2821 } // namespace
2822
renderControl_encoder_context_t(IOStream * stream,ChecksumCalculator * checksumCalculator)2823 renderControl_encoder_context_t::renderControl_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator)
2824 {
2825 m_stream = stream;
2826 m_checksumCalculator = checksumCalculator;
2827
2828 this->rcGetRendererVersion = &rcGetRendererVersion_enc;
2829 this->rcGetEGLVersion = &rcGetEGLVersion_enc;
2830 this->rcQueryEGLString = &rcQueryEGLString_enc;
2831 this->rcGetGLString = &rcGetGLString_enc;
2832 this->rcGetNumConfigs = &rcGetNumConfigs_enc;
2833 this->rcGetConfigs = &rcGetConfigs_enc;
2834 this->rcChooseConfig = &rcChooseConfig_enc;
2835 this->rcGetFBParam = &rcGetFBParam_enc;
2836 this->rcCreateContext = &rcCreateContext_enc;
2837 this->rcDestroyContext = &rcDestroyContext_enc;
2838 this->rcCreateWindowSurface = &rcCreateWindowSurface_enc;
2839 this->rcDestroyWindowSurface = &rcDestroyWindowSurface_enc;
2840 this->rcCreateColorBuffer = &rcCreateColorBuffer_enc;
2841 this->rcOpenColorBuffer = &rcOpenColorBuffer_enc;
2842 this->rcCloseColorBuffer = &rcCloseColorBuffer_enc;
2843 this->rcSetWindowColorBuffer = &rcSetWindowColorBuffer_enc;
2844 this->rcFlushWindowColorBuffer = &rcFlushWindowColorBuffer_enc;
2845 this->rcMakeCurrent = &rcMakeCurrent_enc;
2846 this->rcFBPost = &rcFBPost_enc;
2847 this->rcFBSetSwapInterval = &rcFBSetSwapInterval_enc;
2848 this->rcBindTexture = &rcBindTexture_enc;
2849 this->rcBindRenderbuffer = &rcBindRenderbuffer_enc;
2850 this->rcColorBufferCacheFlush = &rcColorBufferCacheFlush_enc;
2851 this->rcReadColorBuffer = &rcReadColorBuffer_enc;
2852 this->rcUpdateColorBuffer = &rcUpdateColorBuffer_enc;
2853 this->rcOpenColorBuffer2 = &rcOpenColorBuffer2_enc;
2854 this->rcCreateClientImage = &rcCreateClientImage_enc;
2855 this->rcDestroyClientImage = &rcDestroyClientImage_enc;
2856 this->rcSelectChecksumHelper = &rcSelectChecksumHelper_enc;
2857 this->rcCreateSyncKHR = &rcCreateSyncKHR_enc;
2858 this->rcClientWaitSyncKHR = &rcClientWaitSyncKHR_enc;
2859 this->rcFlushWindowColorBufferAsync = &rcFlushWindowColorBufferAsync_enc;
2860 this->rcDestroySyncKHR = &rcDestroySyncKHR_enc;
2861 this->rcSetPuid = &rcSetPuid_enc;
2862 this->rcUpdateColorBufferDMA = &rcUpdateColorBufferDMA_enc;
2863 this->rcCreateColorBufferDMA = &rcCreateColorBufferDMA_enc;
2864 this->rcWaitSyncKHR = &rcWaitSyncKHR_enc;
2865 this->rcCompose = &rcCompose_enc;
2866 this->rcCreateDisplay = &rcCreateDisplay_enc;
2867 this->rcDestroyDisplay = &rcDestroyDisplay_enc;
2868 this->rcSetDisplayColorBuffer = &rcSetDisplayColorBuffer_enc;
2869 this->rcGetDisplayColorBuffer = &rcGetDisplayColorBuffer_enc;
2870 this->rcGetColorBufferDisplay = &rcGetColorBufferDisplay_enc;
2871 this->rcGetDisplayPose = &rcGetDisplayPose_enc;
2872 this->rcSetDisplayPose = &rcSetDisplayPose_enc;
2873 this->rcSetColorBufferVulkanMode = &rcSetColorBufferVulkanMode_enc;
2874 this->rcReadColorBufferYUV = &rcReadColorBufferYUV_enc;
2875 this->rcIsSyncSignaled = &rcIsSyncSignaled_enc;
2876 this->rcCreateColorBufferWithHandle = &rcCreateColorBufferWithHandle_enc;
2877 this->rcCreateBuffer = &rcCreateBuffer_enc;
2878 this->rcCloseBuffer = &rcCloseBuffer_enc;
2879 this->rcSetColorBufferVulkanMode2 = &rcSetColorBufferVulkanMode2_enc;
2880 this->rcMapGpaToBufferHandle = &rcMapGpaToBufferHandle_enc;
2881 this->rcCreateBuffer2 = &rcCreateBuffer2_enc;
2882 this->rcMapGpaToBufferHandle2 = &rcMapGpaToBufferHandle2_enc;
2883 this->rcFlushWindowColorBufferAsyncWithFrameNumber = &rcFlushWindowColorBufferAsyncWithFrameNumber_enc;
2884 this->rcSetTracingForPuid = &rcSetTracingForPuid_enc;
2885 this->rcMakeCurrentAsync = &rcMakeCurrentAsync_enc;
2886 this->rcComposeAsync = &rcComposeAsync_enc;
2887 this->rcDestroySyncKHRAsync = &rcDestroySyncKHRAsync_enc;
2888 this->rcComposeWithoutPost = &rcComposeWithoutPost_enc;
2889 this->rcComposeAsyncWithoutPost = &rcComposeAsyncWithoutPost_enc;
2890 this->rcCreateDisplayById = &rcCreateDisplayById_enc;
2891 this->rcSetDisplayPoseDpi = &rcSetDisplayPoseDpi_enc;
2892 this->rcReadColorBufferDMA = &rcReadColorBufferDMA_enc;
2893 this->rcGetFBDisplayConfigsCount = &rcGetFBDisplayConfigsCount_enc;
2894 this->rcGetFBDisplayConfigsParam = &rcGetFBDisplayConfigsParam_enc;
2895 this->rcGetFBDisplayActiveConfig = &rcGetFBDisplayActiveConfig_enc;
2896 this->rcSetProcessMetadata = &rcSetProcessMetadata_enc;
2897 this->rcGetHostExtensionsString = &rcGetHostExtensionsString_enc;
2898 }
2899
2900