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 namespace {
16
enc_unsupported()17 void enc_unsupported()
18 {
19 ALOGE("Function is unsupported\n");
20 }
21
rcGetRendererVersion_enc(void * self)22 GLint rcGetRendererVersion_enc(void *self )
23 {
24
25 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
26 IOStream *stream = ctx->m_stream;
27 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
28 bool useChecksum = checksumCalculator->getVersion() > 0;
29
30 unsigned char *ptr;
31 unsigned char *buf;
32 const size_t sizeWithoutChecksum = 8;
33 const size_t checksumSize = checksumCalculator->checksumByteSize();
34 const size_t totalSize = sizeWithoutChecksum + checksumSize;
35 buf = stream->alloc(totalSize);
36 ptr = buf;
37 int tmp = OP_rcGetRendererVersion;memcpy(ptr, &tmp, 4); ptr += 4;
38 memcpy(ptr, &totalSize, 4); ptr += 4;
39
40
41 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
42 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
43
44
45 GLint retval;
46 stream->readback(&retval, 4);
47 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
48 if (useChecksum) {
49 unsigned char *checksumBufPtr = NULL;
50 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
51 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
52 stream->readback(checksumBufPtr, checksumSize);
53 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
54 ALOGE("rcGetRendererVersion: GL communication error, please report this issue to b.android.com.\n");
55 abort();
56 }
57 }
58 return retval;
59 }
60
rcGetEGLVersion_enc(void * self,EGLint * major,EGLint * minor)61 EGLint rcGetEGLVersion_enc(void *self , EGLint* major, EGLint* minor)
62 {
63
64 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
65 IOStream *stream = ctx->m_stream;
66 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
67 bool useChecksum = checksumCalculator->getVersion() > 0;
68
69 const unsigned int __size_major = sizeof(EGLint);
70 const unsigned int __size_minor = sizeof(EGLint);
71 unsigned char *ptr;
72 unsigned char *buf;
73 const size_t sizeWithoutChecksum = 8 + 0 + 0 + 2*4;
74 const size_t checksumSize = checksumCalculator->checksumByteSize();
75 const size_t totalSize = sizeWithoutChecksum + checksumSize;
76 buf = stream->alloc(totalSize);
77 ptr = buf;
78 int tmp = OP_rcGetEGLVersion;memcpy(ptr, &tmp, 4); ptr += 4;
79 memcpy(ptr, &totalSize, 4); ptr += 4;
80
81 *(unsigned int *)(ptr) = __size_major; ptr += 4;
82 *(unsigned int *)(ptr) = __size_minor; ptr += 4;
83
84 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
85 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
86
87 stream->readback(major, __size_major);
88 if (useChecksum) checksumCalculator->addBuffer(major, __size_major);
89 stream->readback(minor, __size_minor);
90 if (useChecksum) checksumCalculator->addBuffer(minor, __size_minor);
91
92 EGLint retval;
93 stream->readback(&retval, 4);
94 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
95 if (useChecksum) {
96 unsigned char *checksumBufPtr = NULL;
97 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
98 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
99 stream->readback(checksumBufPtr, checksumSize);
100 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
101 ALOGE("rcGetEGLVersion: GL communication error, please report this issue to b.android.com.\n");
102 abort();
103 }
104 }
105 return retval;
106 }
107
rcQueryEGLString_enc(void * self,EGLenum name,void * buffer,EGLint bufferSize)108 EGLint rcQueryEGLString_enc(void *self , EGLenum name, void* buffer, EGLint bufferSize)
109 {
110
111 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
112 IOStream *stream = ctx->m_stream;
113 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
114 bool useChecksum = checksumCalculator->getVersion() > 0;
115
116 const unsigned int __size_buffer = bufferSize;
117 unsigned char *ptr;
118 unsigned char *buf;
119 const size_t sizeWithoutChecksum = 8 + 4 + 0 + 4 + 1*4;
120 const size_t checksumSize = checksumCalculator->checksumByteSize();
121 const size_t totalSize = sizeWithoutChecksum + checksumSize;
122 buf = stream->alloc(totalSize);
123 ptr = buf;
124 int tmp = OP_rcQueryEGLString;memcpy(ptr, &tmp, 4); ptr += 4;
125 memcpy(ptr, &totalSize, 4); ptr += 4;
126
127 memcpy(ptr, &name, 4); ptr += 4;
128 *(unsigned int *)(ptr) = __size_buffer; ptr += 4;
129 memcpy(ptr, &bufferSize, 4); ptr += 4;
130
131 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
132 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
133
134 stream->readback(buffer, __size_buffer);
135 if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer);
136
137 EGLint retval;
138 stream->readback(&retval, 4);
139 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
140 if (useChecksum) {
141 unsigned char *checksumBufPtr = NULL;
142 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
143 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
144 stream->readback(checksumBufPtr, checksumSize);
145 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
146 ALOGE("rcQueryEGLString: GL communication error, please report this issue to b.android.com.\n");
147 abort();
148 }
149 }
150 return retval;
151 }
152
rcGetGLString_enc(void * self,EGLenum name,void * buffer,EGLint bufferSize)153 EGLint rcGetGLString_enc(void *self , EGLenum name, void* buffer, EGLint bufferSize)
154 {
155
156 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
157 IOStream *stream = ctx->m_stream;
158 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
159 bool useChecksum = checksumCalculator->getVersion() > 0;
160
161 const unsigned int __size_buffer = bufferSize;
162 unsigned char *ptr;
163 unsigned char *buf;
164 const size_t sizeWithoutChecksum = 8 + 4 + 0 + 4 + 1*4;
165 const size_t checksumSize = checksumCalculator->checksumByteSize();
166 const size_t totalSize = sizeWithoutChecksum + checksumSize;
167 buf = stream->alloc(totalSize);
168 ptr = buf;
169 int tmp = OP_rcGetGLString;memcpy(ptr, &tmp, 4); ptr += 4;
170 memcpy(ptr, &totalSize, 4); ptr += 4;
171
172 memcpy(ptr, &name, 4); ptr += 4;
173 *(unsigned int *)(ptr) = __size_buffer; ptr += 4;
174 memcpy(ptr, &bufferSize, 4); ptr += 4;
175
176 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
177 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
178
179 stream->readback(buffer, __size_buffer);
180 if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer);
181
182 EGLint retval;
183 stream->readback(&retval, 4);
184 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
185 if (useChecksum) {
186 unsigned char *checksumBufPtr = NULL;
187 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
188 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
189 stream->readback(checksumBufPtr, checksumSize);
190 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
191 ALOGE("rcGetGLString: GL communication error, please report this issue to b.android.com.\n");
192 abort();
193 }
194 }
195 return retval;
196 }
197
rcGetNumConfigs_enc(void * self,uint32_t * numAttribs)198 EGLint rcGetNumConfigs_enc(void *self , uint32_t* numAttribs)
199 {
200
201 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
202 IOStream *stream = ctx->m_stream;
203 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
204 bool useChecksum = checksumCalculator->getVersion() > 0;
205
206 const unsigned int __size_numAttribs = sizeof(uint32_t);
207 unsigned char *ptr;
208 unsigned char *buf;
209 const size_t sizeWithoutChecksum = 8 + 0 + 1*4;
210 const size_t checksumSize = checksumCalculator->checksumByteSize();
211 const size_t totalSize = sizeWithoutChecksum + checksumSize;
212 buf = stream->alloc(totalSize);
213 ptr = buf;
214 int tmp = OP_rcGetNumConfigs;memcpy(ptr, &tmp, 4); ptr += 4;
215 memcpy(ptr, &totalSize, 4); ptr += 4;
216
217 *(unsigned int *)(ptr) = __size_numAttribs; ptr += 4;
218
219 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
220 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
221
222 stream->readback(numAttribs, __size_numAttribs);
223 if (useChecksum) checksumCalculator->addBuffer(numAttribs, __size_numAttribs);
224
225 EGLint retval;
226 stream->readback(&retval, 4);
227 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
228 if (useChecksum) {
229 unsigned char *checksumBufPtr = NULL;
230 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
231 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
232 stream->readback(checksumBufPtr, checksumSize);
233 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
234 ALOGE("rcGetNumConfigs: GL communication error, please report this issue to b.android.com.\n");
235 abort();
236 }
237 }
238 return retval;
239 }
240
rcGetConfigs_enc(void * self,uint32_t bufSize,GLuint * buffer)241 EGLint rcGetConfigs_enc(void *self , uint32_t bufSize, GLuint* buffer)
242 {
243
244 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
245 IOStream *stream = ctx->m_stream;
246 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
247 bool useChecksum = checksumCalculator->getVersion() > 0;
248
249 const unsigned int __size_buffer = bufSize;
250 unsigned char *ptr;
251 unsigned char *buf;
252 const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
253 const size_t checksumSize = checksumCalculator->checksumByteSize();
254 const size_t totalSize = sizeWithoutChecksum + checksumSize;
255 buf = stream->alloc(totalSize);
256 ptr = buf;
257 int tmp = OP_rcGetConfigs;memcpy(ptr, &tmp, 4); ptr += 4;
258 memcpy(ptr, &totalSize, 4); ptr += 4;
259
260 memcpy(ptr, &bufSize, 4); ptr += 4;
261 *(unsigned int *)(ptr) = __size_buffer; ptr += 4;
262
263 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
264 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
265
266 stream->readback(buffer, __size_buffer);
267 if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer);
268
269 EGLint retval;
270 stream->readback(&retval, 4);
271 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
272 if (useChecksum) {
273 unsigned char *checksumBufPtr = NULL;
274 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
275 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
276 stream->readback(checksumBufPtr, checksumSize);
277 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
278 ALOGE("rcGetConfigs: GL communication error, please report this issue to b.android.com.\n");
279 abort();
280 }
281 }
282 return retval;
283 }
284
rcChooseConfig_enc(void * self,EGLint * attribs,uint32_t attribs_size,uint32_t * configs,uint32_t configs_size)285 EGLint rcChooseConfig_enc(void *self , EGLint* attribs, uint32_t attribs_size, uint32_t* configs, uint32_t configs_size)
286 {
287
288 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
289 IOStream *stream = ctx->m_stream;
290 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
291 bool useChecksum = checksumCalculator->getVersion() > 0;
292
293 const unsigned int __size_attribs = attribs_size;
294 const unsigned int __size_configs = ((configs != NULL) ? configs_size*sizeof(uint32_t) : 0);
295 unsigned char *ptr;
296 unsigned char *buf;
297 const size_t sizeWithoutChecksum = 8 + __size_attribs + 4 + 0 + 4 + 2*4;
298 const size_t checksumSize = checksumCalculator->checksumByteSize();
299 const size_t totalSize = sizeWithoutChecksum + checksumSize;
300 buf = stream->alloc(totalSize);
301 ptr = buf;
302 int tmp = OP_rcChooseConfig;memcpy(ptr, &tmp, 4); ptr += 4;
303 memcpy(ptr, &totalSize, 4); ptr += 4;
304
305 *(unsigned int *)(ptr) = __size_attribs; ptr += 4;
306 memcpy(ptr, attribs, __size_attribs);ptr += __size_attribs;
307 memcpy(ptr, &attribs_size, 4); ptr += 4;
308 *(unsigned int *)(ptr) = __size_configs; ptr += 4;
309 memcpy(ptr, &configs_size, 4); ptr += 4;
310
311 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
312 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
313
314 if (configs != NULL) {
315 stream->readback(configs, __size_configs);
316 if (useChecksum) checksumCalculator->addBuffer(configs, __size_configs);
317 }
318
319 EGLint retval;
320 stream->readback(&retval, 4);
321 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
322 if (useChecksum) {
323 unsigned char *checksumBufPtr = NULL;
324 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
325 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
326 stream->readback(checksumBufPtr, checksumSize);
327 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
328 ALOGE("rcChooseConfig: GL communication error, please report this issue to b.android.com.\n");
329 abort();
330 }
331 }
332 return retval;
333 }
334
rcGetFBParam_enc(void * self,EGLint param)335 EGLint rcGetFBParam_enc(void *self , EGLint param)
336 {
337
338 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
339 IOStream *stream = ctx->m_stream;
340 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
341 bool useChecksum = checksumCalculator->getVersion() > 0;
342
343 unsigned char *ptr;
344 unsigned char *buf;
345 const size_t sizeWithoutChecksum = 8 + 4;
346 const size_t checksumSize = checksumCalculator->checksumByteSize();
347 const size_t totalSize = sizeWithoutChecksum + checksumSize;
348 buf = stream->alloc(totalSize);
349 ptr = buf;
350 int tmp = OP_rcGetFBParam;memcpy(ptr, &tmp, 4); ptr += 4;
351 memcpy(ptr, &totalSize, 4); ptr += 4;
352
353 memcpy(ptr, ¶m, 4); ptr += 4;
354
355 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
356 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
357
358
359 EGLint retval;
360 stream->readback(&retval, 4);
361 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
362 if (useChecksum) {
363 unsigned char *checksumBufPtr = NULL;
364 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
365 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
366 stream->readback(checksumBufPtr, checksumSize);
367 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
368 ALOGE("rcGetFBParam: GL communication error, please report this issue to b.android.com.\n");
369 abort();
370 }
371 }
372 return retval;
373 }
374
rcCreateContext_enc(void * self,uint32_t config,uint32_t share,uint32_t glVersion)375 uint32_t rcCreateContext_enc(void *self , uint32_t config, uint32_t share, uint32_t glVersion)
376 {
377
378 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
379 IOStream *stream = ctx->m_stream;
380 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
381 bool useChecksum = checksumCalculator->getVersion() > 0;
382
383 unsigned char *ptr;
384 unsigned char *buf;
385 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
386 const size_t checksumSize = checksumCalculator->checksumByteSize();
387 const size_t totalSize = sizeWithoutChecksum + checksumSize;
388 buf = stream->alloc(totalSize);
389 ptr = buf;
390 int tmp = OP_rcCreateContext;memcpy(ptr, &tmp, 4); ptr += 4;
391 memcpy(ptr, &totalSize, 4); ptr += 4;
392
393 memcpy(ptr, &config, 4); ptr += 4;
394 memcpy(ptr, &share, 4); ptr += 4;
395 memcpy(ptr, &glVersion, 4); ptr += 4;
396
397 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
398 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
399
400
401 uint32_t retval;
402 stream->readback(&retval, 4);
403 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
404 if (useChecksum) {
405 unsigned char *checksumBufPtr = NULL;
406 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
407 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
408 stream->readback(checksumBufPtr, checksumSize);
409 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
410 ALOGE("rcCreateContext: GL communication error, please report this issue to b.android.com.\n");
411 abort();
412 }
413 }
414 return retval;
415 }
416
rcDestroyContext_enc(void * self,uint32_t context)417 void rcDestroyContext_enc(void *self , uint32_t context)
418 {
419
420 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
421 IOStream *stream = ctx->m_stream;
422 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
423 bool useChecksum = checksumCalculator->getVersion() > 0;
424
425 unsigned char *ptr;
426 unsigned char *buf;
427 const size_t sizeWithoutChecksum = 8 + 4;
428 const size_t checksumSize = checksumCalculator->checksumByteSize();
429 const size_t totalSize = sizeWithoutChecksum + checksumSize;
430 buf = stream->alloc(totalSize);
431 ptr = buf;
432 int tmp = OP_rcDestroyContext;memcpy(ptr, &tmp, 4); ptr += 4;
433 memcpy(ptr, &totalSize, 4); ptr += 4;
434
435 memcpy(ptr, &context, 4); ptr += 4;
436
437 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
438 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
439
440 }
441
rcCreateWindowSurface_enc(void * self,uint32_t config,uint32_t width,uint32_t height)442 uint32_t rcCreateWindowSurface_enc(void *self , uint32_t config, uint32_t width, uint32_t height)
443 {
444
445 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
446 IOStream *stream = ctx->m_stream;
447 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
448 bool useChecksum = checksumCalculator->getVersion() > 0;
449
450 unsigned char *ptr;
451 unsigned char *buf;
452 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
453 const size_t checksumSize = checksumCalculator->checksumByteSize();
454 const size_t totalSize = sizeWithoutChecksum + checksumSize;
455 buf = stream->alloc(totalSize);
456 ptr = buf;
457 int tmp = OP_rcCreateWindowSurface;memcpy(ptr, &tmp, 4); ptr += 4;
458 memcpy(ptr, &totalSize, 4); ptr += 4;
459
460 memcpy(ptr, &config, 4); ptr += 4;
461 memcpy(ptr, &width, 4); ptr += 4;
462 memcpy(ptr, &height, 4); ptr += 4;
463
464 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
465 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
466
467
468 uint32_t retval;
469 stream->readback(&retval, 4);
470 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
471 if (useChecksum) {
472 unsigned char *checksumBufPtr = NULL;
473 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
474 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
475 stream->readback(checksumBufPtr, checksumSize);
476 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
477 ALOGE("rcCreateWindowSurface: GL communication error, please report this issue to b.android.com.\n");
478 abort();
479 }
480 }
481 return retval;
482 }
483
rcDestroyWindowSurface_enc(void * self,uint32_t windowSurface)484 void rcDestroyWindowSurface_enc(void *self , uint32_t windowSurface)
485 {
486
487 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
488 IOStream *stream = ctx->m_stream;
489 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
490 bool useChecksum = checksumCalculator->getVersion() > 0;
491
492 unsigned char *ptr;
493 unsigned char *buf;
494 const size_t sizeWithoutChecksum = 8 + 4;
495 const size_t checksumSize = checksumCalculator->checksumByteSize();
496 const size_t totalSize = sizeWithoutChecksum + checksumSize;
497 buf = stream->alloc(totalSize);
498 ptr = buf;
499 int tmp = OP_rcDestroyWindowSurface;memcpy(ptr, &tmp, 4); ptr += 4;
500 memcpy(ptr, &totalSize, 4); ptr += 4;
501
502 memcpy(ptr, &windowSurface, 4); ptr += 4;
503
504 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
505 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
506
507 }
508
rcCreateColorBuffer_enc(void * self,uint32_t width,uint32_t height,GLenum internalFormat)509 uint32_t rcCreateColorBuffer_enc(void *self , uint32_t width, uint32_t height, GLenum internalFormat)
510 {
511
512 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
513 IOStream *stream = ctx->m_stream;
514 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
515 bool useChecksum = checksumCalculator->getVersion() > 0;
516
517 unsigned char *ptr;
518 unsigned char *buf;
519 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
520 const size_t checksumSize = checksumCalculator->checksumByteSize();
521 const size_t totalSize = sizeWithoutChecksum + checksumSize;
522 buf = stream->alloc(totalSize);
523 ptr = buf;
524 int tmp = OP_rcCreateColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
525 memcpy(ptr, &totalSize, 4); ptr += 4;
526
527 memcpy(ptr, &width, 4); ptr += 4;
528 memcpy(ptr, &height, 4); ptr += 4;
529 memcpy(ptr, &internalFormat, 4); ptr += 4;
530
531 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
532 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
533
534
535 uint32_t retval;
536 stream->readback(&retval, 4);
537 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
538 if (useChecksum) {
539 unsigned char *checksumBufPtr = NULL;
540 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
541 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
542 stream->readback(checksumBufPtr, checksumSize);
543 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
544 ALOGE("rcCreateColorBuffer: GL communication error, please report this issue to b.android.com.\n");
545 abort();
546 }
547 }
548 return retval;
549 }
550
rcOpenColorBuffer_enc(void * self,uint32_t colorbuffer)551 void rcOpenColorBuffer_enc(void *self , uint32_t colorbuffer)
552 {
553
554 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
555 IOStream *stream = ctx->m_stream;
556 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
557 bool useChecksum = checksumCalculator->getVersion() > 0;
558
559 unsigned char *ptr;
560 unsigned char *buf;
561 const size_t sizeWithoutChecksum = 8 + 4;
562 const size_t checksumSize = checksumCalculator->checksumByteSize();
563 const size_t totalSize = sizeWithoutChecksum + checksumSize;
564 buf = stream->alloc(totalSize);
565 ptr = buf;
566 int tmp = OP_rcOpenColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
567 memcpy(ptr, &totalSize, 4); ptr += 4;
568
569 memcpy(ptr, &colorbuffer, 4); ptr += 4;
570
571 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
572 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
573
574 }
575
rcCloseColorBuffer_enc(void * self,uint32_t colorbuffer)576 void rcCloseColorBuffer_enc(void *self , uint32_t colorbuffer)
577 {
578
579 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
580 IOStream *stream = ctx->m_stream;
581 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
582 bool useChecksum = checksumCalculator->getVersion() > 0;
583
584 unsigned char *ptr;
585 unsigned char *buf;
586 const size_t sizeWithoutChecksum = 8 + 4;
587 const size_t checksumSize = checksumCalculator->checksumByteSize();
588 const size_t totalSize = sizeWithoutChecksum + checksumSize;
589 buf = stream->alloc(totalSize);
590 ptr = buf;
591 int tmp = OP_rcCloseColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
592 memcpy(ptr, &totalSize, 4); ptr += 4;
593
594 memcpy(ptr, &colorbuffer, 4); ptr += 4;
595
596 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
597 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
598
599 stream->flush();
600 }
601
rcSetWindowColorBuffer_enc(void * self,uint32_t windowSurface,uint32_t colorBuffer)602 void rcSetWindowColorBuffer_enc(void *self , uint32_t windowSurface, uint32_t colorBuffer)
603 {
604
605 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
606 IOStream *stream = ctx->m_stream;
607 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
608 bool useChecksum = checksumCalculator->getVersion() > 0;
609
610 unsigned char *ptr;
611 unsigned char *buf;
612 const size_t sizeWithoutChecksum = 8 + 4 + 4;
613 const size_t checksumSize = checksumCalculator->checksumByteSize();
614 const size_t totalSize = sizeWithoutChecksum + checksumSize;
615 buf = stream->alloc(totalSize);
616 ptr = buf;
617 int tmp = OP_rcSetWindowColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
618 memcpy(ptr, &totalSize, 4); ptr += 4;
619
620 memcpy(ptr, &windowSurface, 4); ptr += 4;
621 memcpy(ptr, &colorBuffer, 4); ptr += 4;
622
623 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
624 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
625
626 }
627
rcFlushWindowColorBuffer_enc(void * self,uint32_t windowSurface)628 int rcFlushWindowColorBuffer_enc(void *self , uint32_t windowSurface)
629 {
630
631 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
632 IOStream *stream = ctx->m_stream;
633 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
634 bool useChecksum = checksumCalculator->getVersion() > 0;
635
636 unsigned char *ptr;
637 unsigned char *buf;
638 const size_t sizeWithoutChecksum = 8 + 4;
639 const size_t checksumSize = checksumCalculator->checksumByteSize();
640 const size_t totalSize = sizeWithoutChecksum + checksumSize;
641 buf = stream->alloc(totalSize);
642 ptr = buf;
643 int tmp = OP_rcFlushWindowColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
644 memcpy(ptr, &totalSize, 4); ptr += 4;
645
646 memcpy(ptr, &windowSurface, 4); ptr += 4;
647
648 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
649 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
650
651
652 int retval;
653 stream->readback(&retval, 4);
654 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
655 if (useChecksum) {
656 unsigned char *checksumBufPtr = NULL;
657 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
658 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
659 stream->readback(checksumBufPtr, checksumSize);
660 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
661 ALOGE("rcFlushWindowColorBuffer: GL communication error, please report this issue to b.android.com.\n");
662 abort();
663 }
664 }
665 return retval;
666 }
667
rcMakeCurrent_enc(void * self,uint32_t context,uint32_t drawSurf,uint32_t readSurf)668 EGLint rcMakeCurrent_enc(void *self , uint32_t context, uint32_t drawSurf, uint32_t readSurf)
669 {
670
671 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
672 IOStream *stream = ctx->m_stream;
673 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
674 bool useChecksum = checksumCalculator->getVersion() > 0;
675
676 unsigned char *ptr;
677 unsigned char *buf;
678 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
679 const size_t checksumSize = checksumCalculator->checksumByteSize();
680 const size_t totalSize = sizeWithoutChecksum + checksumSize;
681 buf = stream->alloc(totalSize);
682 ptr = buf;
683 int tmp = OP_rcMakeCurrent;memcpy(ptr, &tmp, 4); ptr += 4;
684 memcpy(ptr, &totalSize, 4); ptr += 4;
685
686 memcpy(ptr, &context, 4); ptr += 4;
687 memcpy(ptr, &drawSurf, 4); ptr += 4;
688 memcpy(ptr, &readSurf, 4); ptr += 4;
689
690 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
691 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
692
693
694 EGLint 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[ChecksumCalculator::kMaxChecksumSize];
700 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
701 stream->readback(checksumBufPtr, checksumSize);
702 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
703 ALOGE("rcMakeCurrent: GL communication error, please report this issue to b.android.com.\n");
704 abort();
705 }
706 }
707 return retval;
708 }
709
rcFBPost_enc(void * self,uint32_t colorBuffer)710 void rcFBPost_enc(void *self , uint32_t colorBuffer)
711 {
712
713 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
714 IOStream *stream = ctx->m_stream;
715 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
716 bool useChecksum = checksumCalculator->getVersion() > 0;
717
718 unsigned char *ptr;
719 unsigned char *buf;
720 const size_t sizeWithoutChecksum = 8 + 4;
721 const size_t checksumSize = checksumCalculator->checksumByteSize();
722 const size_t totalSize = sizeWithoutChecksum + checksumSize;
723 buf = stream->alloc(totalSize);
724 ptr = buf;
725 int tmp = OP_rcFBPost;memcpy(ptr, &tmp, 4); ptr += 4;
726 memcpy(ptr, &totalSize, 4); ptr += 4;
727
728 memcpy(ptr, &colorBuffer, 4); ptr += 4;
729
730 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
731 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
732
733 }
734
rcFBSetSwapInterval_enc(void * self,EGLint interval)735 void rcFBSetSwapInterval_enc(void *self , EGLint interval)
736 {
737
738 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
739 IOStream *stream = ctx->m_stream;
740 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
741 bool useChecksum = checksumCalculator->getVersion() > 0;
742
743 unsigned char *ptr;
744 unsigned char *buf;
745 const size_t sizeWithoutChecksum = 8 + 4;
746 const size_t checksumSize = checksumCalculator->checksumByteSize();
747 const size_t totalSize = sizeWithoutChecksum + checksumSize;
748 buf = stream->alloc(totalSize);
749 ptr = buf;
750 int tmp = OP_rcFBSetSwapInterval;memcpy(ptr, &tmp, 4); ptr += 4;
751 memcpy(ptr, &totalSize, 4); ptr += 4;
752
753 memcpy(ptr, &interval, 4); ptr += 4;
754
755 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
756 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
757
758 }
759
rcBindTexture_enc(void * self,uint32_t colorBuffer)760 void rcBindTexture_enc(void *self , uint32_t colorBuffer)
761 {
762
763 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
764 IOStream *stream = ctx->m_stream;
765 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
766 bool useChecksum = checksumCalculator->getVersion() > 0;
767
768 unsigned char *ptr;
769 unsigned char *buf;
770 const size_t sizeWithoutChecksum = 8 + 4;
771 const size_t checksumSize = checksumCalculator->checksumByteSize();
772 const size_t totalSize = sizeWithoutChecksum + checksumSize;
773 buf = stream->alloc(totalSize);
774 ptr = buf;
775 int tmp = OP_rcBindTexture;memcpy(ptr, &tmp, 4); ptr += 4;
776 memcpy(ptr, &totalSize, 4); ptr += 4;
777
778 memcpy(ptr, &colorBuffer, 4); ptr += 4;
779
780 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
781 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
782
783 }
784
rcBindRenderbuffer_enc(void * self,uint32_t colorBuffer)785 void rcBindRenderbuffer_enc(void *self , uint32_t colorBuffer)
786 {
787
788 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
789 IOStream *stream = ctx->m_stream;
790 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
791 bool useChecksum = checksumCalculator->getVersion() > 0;
792
793 unsigned char *ptr;
794 unsigned char *buf;
795 const size_t sizeWithoutChecksum = 8 + 4;
796 const size_t checksumSize = checksumCalculator->checksumByteSize();
797 const size_t totalSize = sizeWithoutChecksum + checksumSize;
798 buf = stream->alloc(totalSize);
799 ptr = buf;
800 int tmp = OP_rcBindRenderbuffer;memcpy(ptr, &tmp, 4); ptr += 4;
801 memcpy(ptr, &totalSize, 4); ptr += 4;
802
803 memcpy(ptr, &colorBuffer, 4); ptr += 4;
804
805 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
806 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
807
808 }
809
rcColorBufferCacheFlush_enc(void * self,uint32_t colorbuffer,EGLint postCount,int forRead)810 EGLint rcColorBufferCacheFlush_enc(void *self , uint32_t colorbuffer, EGLint postCount, int forRead)
811 {
812
813 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
814 IOStream *stream = ctx->m_stream;
815 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 + 4 + 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_rcColorBufferCacheFlush;memcpy(ptr, &tmp, 4); ptr += 4;
826 memcpy(ptr, &totalSize, 4); ptr += 4;
827
828 memcpy(ptr, &colorbuffer, 4); ptr += 4;
829 memcpy(ptr, &postCount, 4); ptr += 4;
830 memcpy(ptr, &forRead, 4); ptr += 4;
831
832 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
833 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
834
835
836 EGLint retval;
837 stream->readback(&retval, 4);
838 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
839 if (useChecksum) {
840 unsigned char *checksumBufPtr = NULL;
841 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
842 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
843 stream->readback(checksumBufPtr, checksumSize);
844 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
845 ALOGE("rcColorBufferCacheFlush: GL communication error, please report this issue to b.android.com.\n");
846 abort();
847 }
848 }
849 return retval;
850 }
851
rcReadColorBuffer_enc(void * self,uint32_t colorbuffer,GLint x,GLint y,GLint width,GLint height,GLenum format,GLenum type,void * pixels)852 void rcReadColorBuffer_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels)
853 {
854
855 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
856 IOStream *stream = ctx->m_stream;
857 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
858 bool useChecksum = checksumCalculator->getVersion() > 0;
859
860 const unsigned int __size_pixels = (((glUtilsPixelBitSize(format, type) * width) >> 3) * height);
861 unsigned char *ptr;
862 unsigned char *buf;
863 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 0 + 1*4;
864 const size_t checksumSize = checksumCalculator->checksumByteSize();
865 const size_t totalSize = sizeWithoutChecksum + checksumSize;
866 buf = stream->alloc(totalSize);
867 ptr = buf;
868 int tmp = OP_rcReadColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
869 memcpy(ptr, &totalSize, 4); ptr += 4;
870
871 memcpy(ptr, &colorbuffer, 4); ptr += 4;
872 memcpy(ptr, &x, 4); ptr += 4;
873 memcpy(ptr, &y, 4); ptr += 4;
874 memcpy(ptr, &width, 4); ptr += 4;
875 memcpy(ptr, &height, 4); ptr += 4;
876 memcpy(ptr, &format, 4); ptr += 4;
877 memcpy(ptr, &type, 4); ptr += 4;
878 *(unsigned int *)(ptr) = __size_pixels; ptr += 4;
879
880 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
881 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
882
883 stream->readback(pixels, __size_pixels);
884 if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
885 if (useChecksum) {
886 unsigned char *checksumBufPtr = NULL;
887 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
888 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
889 stream->readback(checksumBufPtr, checksumSize);
890 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
891 ALOGE("rcReadColorBuffer: GL communication error, please report this issue to b.android.com.\n");
892 abort();
893 }
894 }
895 }
896
rcUpdateColorBuffer_enc(void * self,uint32_t colorbuffer,GLint x,GLint y,GLint width,GLint height,GLenum format,GLenum type,void * pixels)897 int rcUpdateColorBuffer_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels)
898 {
899
900 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
901 IOStream *stream = ctx->m_stream;
902 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
903 bool useChecksum = checksumCalculator->getVersion() > 0;
904
905 const unsigned int __size_pixels = (((glUtilsPixelBitSize(format, type) * width) >> 3) * height);
906 unsigned char *ptr;
907 unsigned char *buf;
908 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
909 const size_t checksumSize = checksumCalculator->checksumByteSize();
910 const size_t totalSize = sizeWithoutChecksum + checksumSize;
911 buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
912 ptr = buf;
913 int tmp = OP_rcUpdateColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
914 memcpy(ptr, &totalSize, 4); ptr += 4;
915
916 memcpy(ptr, &colorbuffer, 4); ptr += 4;
917 memcpy(ptr, &x, 4); ptr += 4;
918 memcpy(ptr, &y, 4); ptr += 4;
919 memcpy(ptr, &width, 4); ptr += 4;
920 memcpy(ptr, &height, 4); ptr += 4;
921 memcpy(ptr, &format, 4); ptr += 4;
922 memcpy(ptr, &type, 4); ptr += 4;
923
924 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
925 stream->flush();
926 stream->writeFully(&__size_pixels,4);
927 if (useChecksum) checksumCalculator->addBuffer(&__size_pixels,4);
928 stream->writeFully(pixels, __size_pixels);
929 if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
930 buf = stream->alloc(checksumSize);
931 if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
932
933
934 int retval;
935 stream->readback(&retval, 4);
936 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
937 if (useChecksum) {
938 unsigned char *checksumBufPtr = NULL;
939 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
940 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
941 stream->readback(checksumBufPtr, checksumSize);
942 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
943 ALOGE("rcUpdateColorBuffer: GL communication error, please report this issue to b.android.com.\n");
944 abort();
945 }
946 }
947 return retval;
948 }
949
rcOpenColorBuffer2_enc(void * self,uint32_t colorbuffer)950 int rcOpenColorBuffer2_enc(void *self , uint32_t colorbuffer)
951 {
952
953 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
954 IOStream *stream = ctx->m_stream;
955 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
956 bool useChecksum = checksumCalculator->getVersion() > 0;
957
958 unsigned char *ptr;
959 unsigned char *buf;
960 const size_t sizeWithoutChecksum = 8 + 4;
961 const size_t checksumSize = checksumCalculator->checksumByteSize();
962 const size_t totalSize = sizeWithoutChecksum + checksumSize;
963 buf = stream->alloc(totalSize);
964 ptr = buf;
965 int tmp = OP_rcOpenColorBuffer2;memcpy(ptr, &tmp, 4); ptr += 4;
966 memcpy(ptr, &totalSize, 4); ptr += 4;
967
968 memcpy(ptr, &colorbuffer, 4); ptr += 4;
969
970 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
971 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
972
973
974 int retval;
975 stream->readback(&retval, 4);
976 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
977 if (useChecksum) {
978 unsigned char *checksumBufPtr = NULL;
979 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
980 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
981 stream->readback(checksumBufPtr, checksumSize);
982 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
983 ALOGE("rcOpenColorBuffer2: GL communication error, please report this issue to b.android.com.\n");
984 abort();
985 }
986 }
987 return retval;
988 }
989
rcCreateClientImage_enc(void * self,uint32_t context,EGLenum target,GLuint buffer)990 uint32_t rcCreateClientImage_enc(void *self , uint32_t context, EGLenum target, GLuint buffer)
991 {
992
993 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
994 IOStream *stream = ctx->m_stream;
995 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
996 bool useChecksum = checksumCalculator->getVersion() > 0;
997
998 unsigned char *ptr;
999 unsigned char *buf;
1000 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
1001 const size_t checksumSize = checksumCalculator->checksumByteSize();
1002 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1003 buf = stream->alloc(totalSize);
1004 ptr = buf;
1005 int tmp = OP_rcCreateClientImage;memcpy(ptr, &tmp, 4); ptr += 4;
1006 memcpy(ptr, &totalSize, 4); ptr += 4;
1007
1008 memcpy(ptr, &context, 4); ptr += 4;
1009 memcpy(ptr, &target, 4); ptr += 4;
1010 memcpy(ptr, &buffer, 4); ptr += 4;
1011
1012 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1013 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1014
1015
1016 uint32_t retval;
1017 stream->readback(&retval, 4);
1018 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1019 if (useChecksum) {
1020 unsigned char *checksumBufPtr = NULL;
1021 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1022 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1023 stream->readback(checksumBufPtr, checksumSize);
1024 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1025 ALOGE("rcCreateClientImage: GL communication error, please report this issue to b.android.com.\n");
1026 abort();
1027 }
1028 }
1029 return retval;
1030 }
1031
rcDestroyClientImage_enc(void * self,uint32_t image)1032 int rcDestroyClientImage_enc(void *self , uint32_t image)
1033 {
1034
1035 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1036 IOStream *stream = ctx->m_stream;
1037 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1038 bool useChecksum = checksumCalculator->getVersion() > 0;
1039
1040 unsigned char *ptr;
1041 unsigned char *buf;
1042 const size_t sizeWithoutChecksum = 8 + 4;
1043 const size_t checksumSize = checksumCalculator->checksumByteSize();
1044 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1045 buf = stream->alloc(totalSize);
1046 ptr = buf;
1047 int tmp = OP_rcDestroyClientImage;memcpy(ptr, &tmp, 4); ptr += 4;
1048 memcpy(ptr, &totalSize, 4); ptr += 4;
1049
1050 memcpy(ptr, &image, 4); ptr += 4;
1051
1052 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1053 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1054
1055
1056 int retval;
1057 stream->readback(&retval, 4);
1058 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1059 if (useChecksum) {
1060 unsigned char *checksumBufPtr = NULL;
1061 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1062 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1063 stream->readback(checksumBufPtr, checksumSize);
1064 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1065 ALOGE("rcDestroyClientImage: GL communication error, please report this issue to b.android.com.\n");
1066 abort();
1067 }
1068 }
1069 return retval;
1070 }
1071
rcSelectChecksumHelper_enc(void * self,uint32_t newProtocol,uint32_t reserved)1072 void rcSelectChecksumHelper_enc(void *self , uint32_t newProtocol, uint32_t reserved)
1073 {
1074
1075 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1076 IOStream *stream = ctx->m_stream;
1077 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1078 bool useChecksum = checksumCalculator->getVersion() > 0;
1079
1080 unsigned char *ptr;
1081 unsigned char *buf;
1082 const size_t sizeWithoutChecksum = 8 + 4 + 4;
1083 const size_t checksumSize = checksumCalculator->checksumByteSize();
1084 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1085 buf = stream->alloc(totalSize);
1086 ptr = buf;
1087 int tmp = OP_rcSelectChecksumHelper;memcpy(ptr, &tmp, 4); ptr += 4;
1088 memcpy(ptr, &totalSize, 4); ptr += 4;
1089
1090 memcpy(ptr, &newProtocol, 4); ptr += 4;
1091 memcpy(ptr, &reserved, 4); ptr += 4;
1092
1093 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1094 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1095
1096 }
1097
rcCreateSyncKHR_enc(void * self,EGLenum type,EGLint * attribs,uint32_t num_attribs,int destroy_when_signaled,uint64_t * glsync_out,uint64_t * syncthread_out)1098 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)
1099 {
1100
1101 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1102 IOStream *stream = ctx->m_stream;
1103 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1104 bool useChecksum = checksumCalculator->getVersion() > 0;
1105
1106 const unsigned int __size_attribs = num_attribs;
1107 const unsigned int __size_glsync_out = sizeof(uint64_t);
1108 const unsigned int __size_syncthread_out = sizeof(uint64_t);
1109 unsigned char *ptr;
1110 unsigned char *buf;
1111 const size_t sizeWithoutChecksum = 8 + 4 + __size_attribs + 4 + 4 + 0 + 0 + 3*4;
1112 const size_t checksumSize = checksumCalculator->checksumByteSize();
1113 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1114 buf = stream->alloc(totalSize);
1115 ptr = buf;
1116 int tmp = OP_rcCreateSyncKHR;memcpy(ptr, &tmp, 4); ptr += 4;
1117 memcpy(ptr, &totalSize, 4); ptr += 4;
1118
1119 memcpy(ptr, &type, 4); ptr += 4;
1120 *(unsigned int *)(ptr) = __size_attribs; ptr += 4;
1121 memcpy(ptr, attribs, __size_attribs);ptr += __size_attribs;
1122 memcpy(ptr, &num_attribs, 4); ptr += 4;
1123 memcpy(ptr, &destroy_when_signaled, 4); ptr += 4;
1124 *(unsigned int *)(ptr) = __size_glsync_out; ptr += 4;
1125 *(unsigned int *)(ptr) = __size_syncthread_out; ptr += 4;
1126
1127 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1128 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1129
1130 stream->readback(glsync_out, __size_glsync_out);
1131 if (useChecksum) checksumCalculator->addBuffer(glsync_out, __size_glsync_out);
1132 stream->readback(syncthread_out, __size_syncthread_out);
1133 if (useChecksum) checksumCalculator->addBuffer(syncthread_out, __size_syncthread_out);
1134 if (useChecksum) {
1135 unsigned char *checksumBufPtr = NULL;
1136 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1137 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1138 stream->readback(checksumBufPtr, checksumSize);
1139 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1140 ALOGE("rcCreateSyncKHR: GL communication error, please report this issue to b.android.com.\n");
1141 abort();
1142 }
1143 }
1144 }
1145
rcClientWaitSyncKHR_enc(void * self,uint64_t sync,EGLint flags,uint64_t timeout)1146 EGLint rcClientWaitSyncKHR_enc(void *self , uint64_t sync, EGLint flags, uint64_t timeout)
1147 {
1148
1149 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1150 IOStream *stream = ctx->m_stream;
1151 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1152 bool useChecksum = checksumCalculator->getVersion() > 0;
1153
1154 unsigned char *ptr;
1155 unsigned char *buf;
1156 const size_t sizeWithoutChecksum = 8 + 8 + 4 + 8;
1157 const size_t checksumSize = checksumCalculator->checksumByteSize();
1158 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1159 buf = stream->alloc(totalSize);
1160 ptr = buf;
1161 int tmp = OP_rcClientWaitSyncKHR;memcpy(ptr, &tmp, 4); ptr += 4;
1162 memcpy(ptr, &totalSize, 4); ptr += 4;
1163
1164 memcpy(ptr, &sync, 8); ptr += 8;
1165 memcpy(ptr, &flags, 4); ptr += 4;
1166 memcpy(ptr, &timeout, 8); ptr += 8;
1167
1168 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1169 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1170
1171
1172 EGLint retval;
1173 stream->readback(&retval, 4);
1174 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1175 if (useChecksum) {
1176 unsigned char *checksumBufPtr = NULL;
1177 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1178 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1179 stream->readback(checksumBufPtr, checksumSize);
1180 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1181 ALOGE("rcClientWaitSyncKHR: GL communication error, please report this issue to b.android.com.\n");
1182 abort();
1183 }
1184 }
1185 return retval;
1186 }
1187
rcFlushWindowColorBufferAsync_enc(void * self,uint32_t windowSurface)1188 void rcFlushWindowColorBufferAsync_enc(void *self , uint32_t windowSurface)
1189 {
1190
1191 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1192 IOStream *stream = ctx->m_stream;
1193 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1194 bool useChecksum = checksumCalculator->getVersion() > 0;
1195
1196 unsigned char *ptr;
1197 unsigned char *buf;
1198 const size_t sizeWithoutChecksum = 8 + 4;
1199 const size_t checksumSize = checksumCalculator->checksumByteSize();
1200 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1201 buf = stream->alloc(totalSize);
1202 ptr = buf;
1203 int tmp = OP_rcFlushWindowColorBufferAsync;memcpy(ptr, &tmp, 4); ptr += 4;
1204 memcpy(ptr, &totalSize, 4); ptr += 4;
1205
1206 memcpy(ptr, &windowSurface, 4); ptr += 4;
1207
1208 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1209 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1210
1211 }
1212
rcDestroySyncKHR_enc(void * self,uint64_t sync)1213 int rcDestroySyncKHR_enc(void *self , uint64_t sync)
1214 {
1215
1216 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1217 IOStream *stream = ctx->m_stream;
1218 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1219 bool useChecksum = checksumCalculator->getVersion() > 0;
1220
1221 unsigned char *ptr;
1222 unsigned char *buf;
1223 const size_t sizeWithoutChecksum = 8 + 8;
1224 const size_t checksumSize = checksumCalculator->checksumByteSize();
1225 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1226 buf = stream->alloc(totalSize);
1227 ptr = buf;
1228 int tmp = OP_rcDestroySyncKHR;memcpy(ptr, &tmp, 4); ptr += 4;
1229 memcpy(ptr, &totalSize, 4); ptr += 4;
1230
1231 memcpy(ptr, &sync, 8); ptr += 8;
1232
1233 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1234 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1235
1236
1237 int retval;
1238 stream->readback(&retval, 4);
1239 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1240 if (useChecksum) {
1241 unsigned char *checksumBufPtr = NULL;
1242 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1243 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1244 stream->readback(checksumBufPtr, checksumSize);
1245 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1246 ALOGE("rcDestroySyncKHR: GL communication error, please report this issue to b.android.com.\n");
1247 abort();
1248 }
1249 }
1250 return retval;
1251 }
1252
rcSetPuid_enc(void * self,uint64_t puid)1253 void rcSetPuid_enc(void *self , uint64_t puid)
1254 {
1255
1256 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1257 IOStream *stream = ctx->m_stream;
1258 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1259 bool useChecksum = checksumCalculator->getVersion() > 0;
1260
1261 unsigned char *ptr;
1262 unsigned char *buf;
1263 const size_t sizeWithoutChecksum = 8 + 8;
1264 const size_t checksumSize = checksumCalculator->checksumByteSize();
1265 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1266 buf = stream->alloc(totalSize);
1267 ptr = buf;
1268 int tmp = OP_rcSetPuid;memcpy(ptr, &tmp, 4); ptr += 4;
1269 memcpy(ptr, &totalSize, 4); ptr += 4;
1270
1271 memcpy(ptr, &puid, 8); ptr += 8;
1272
1273 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1274 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1275
1276 }
1277
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)1278 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)
1279 {
1280
1281 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1282 IOStream *stream = ctx->m_stream;
1283 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1284 bool useChecksum = checksumCalculator->getVersion() > 0;
1285
1286 const unsigned int __size_pixels = pixels_size;
1287 unsigned char *ptr;
1288 unsigned char *buf;
1289 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 8 + 4 + 1*4;
1290 const size_t checksumSize = checksumCalculator->checksumByteSize();
1291 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1292 buf = stream->alloc(totalSize);
1293 ptr = buf;
1294 int tmp = OP_rcUpdateColorBufferDMA;memcpy(ptr, &tmp, 4); ptr += 4;
1295 memcpy(ptr, &totalSize, 4); ptr += 4;
1296
1297 memcpy(ptr, &colorbuffer, 4); ptr += 4;
1298 memcpy(ptr, &x, 4); ptr += 4;
1299 memcpy(ptr, &y, 4); ptr += 4;
1300 memcpy(ptr, &width, 4); ptr += 4;
1301 memcpy(ptr, &height, 4); ptr += 4;
1302 memcpy(ptr, &format, 4); ptr += 4;
1303 memcpy(ptr, &type, 4); ptr += 4;
1304 *(uint64_t *)(ptr) = ctx->lockAndWriteDma(pixels, __size_pixels); ptr += 8;
1305 memcpy(ptr, &pixels_size, 4); ptr += 4;
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[ChecksumCalculator::kMaxChecksumSize];
1317 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1318 stream->readback(checksumBufPtr, checksumSize);
1319 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1320 ALOGE("rcUpdateColorBufferDMA: GL communication error, please report this issue to b.android.com.\n");
1321 abort();
1322 }
1323 }
1324 return retval;
1325 }
1326
rcCreateColorBufferDMA_enc(void * self,uint32_t width,uint32_t height,GLenum internalFormat,int frameworkFormat)1327 uint32_t rcCreateColorBufferDMA_enc(void *self , uint32_t width, uint32_t height, GLenum internalFormat, int frameworkFormat)
1328 {
1329
1330 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1331 IOStream *stream = ctx->m_stream;
1332 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1333 bool useChecksum = checksumCalculator->getVersion() > 0;
1334
1335 unsigned char *ptr;
1336 unsigned char *buf;
1337 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
1338 const size_t checksumSize = checksumCalculator->checksumByteSize();
1339 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1340 buf = stream->alloc(totalSize);
1341 ptr = buf;
1342 int tmp = OP_rcCreateColorBufferDMA;memcpy(ptr, &tmp, 4); ptr += 4;
1343 memcpy(ptr, &totalSize, 4); ptr += 4;
1344
1345 memcpy(ptr, &width, 4); ptr += 4;
1346 memcpy(ptr, &height, 4); ptr += 4;
1347 memcpy(ptr, &internalFormat, 4); ptr += 4;
1348 memcpy(ptr, &frameworkFormat, 4); ptr += 4;
1349
1350 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1351 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1352
1353
1354 uint32_t retval;
1355 stream->readback(&retval, 4);
1356 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1357 if (useChecksum) {
1358 unsigned char *checksumBufPtr = NULL;
1359 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1360 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1361 stream->readback(checksumBufPtr, checksumSize);
1362 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1363 ALOGE("rcCreateColorBufferDMA: GL communication error, please report this issue to b.android.com.\n");
1364 abort();
1365 }
1366 }
1367 return retval;
1368 }
1369
rcWaitSyncKHR_enc(void * self,uint64_t sync,EGLint flags)1370 void rcWaitSyncKHR_enc(void *self , uint64_t sync, EGLint flags)
1371 {
1372
1373 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1374 IOStream *stream = ctx->m_stream;
1375 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1376 bool useChecksum = checksumCalculator->getVersion() > 0;
1377
1378 unsigned char *ptr;
1379 unsigned char *buf;
1380 const size_t sizeWithoutChecksum = 8 + 8 + 4;
1381 const size_t checksumSize = checksumCalculator->checksumByteSize();
1382 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1383 buf = stream->alloc(totalSize);
1384 ptr = buf;
1385 int tmp = OP_rcWaitSyncKHR;memcpy(ptr, &tmp, 4); ptr += 4;
1386 memcpy(ptr, &totalSize, 4); ptr += 4;
1387
1388 memcpy(ptr, &sync, 8); ptr += 8;
1389 memcpy(ptr, &flags, 4); ptr += 4;
1390
1391 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1392 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1393
1394 }
1395
rcCompose_enc(void * self,uint32_t bufferSize,void * buffer)1396 GLint rcCompose_enc(void *self , uint32_t bufferSize, void* buffer)
1397 {
1398
1399 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1400 IOStream *stream = ctx->m_stream;
1401 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1402 bool useChecksum = checksumCalculator->getVersion() > 0;
1403
1404 const unsigned int __size_buffer = bufferSize;
1405 unsigned char *ptr;
1406 unsigned char *buf;
1407 const size_t sizeWithoutChecksum = 8 + 4 + __size_buffer + 1*4;
1408 const size_t checksumSize = checksumCalculator->checksumByteSize();
1409 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1410 buf = stream->alloc(totalSize);
1411 ptr = buf;
1412 int tmp = OP_rcCompose;memcpy(ptr, &tmp, 4); ptr += 4;
1413 memcpy(ptr, &totalSize, 4); ptr += 4;
1414
1415 memcpy(ptr, &bufferSize, 4); ptr += 4;
1416 *(unsigned int *)(ptr) = __size_buffer; ptr += 4;
1417 memcpy(ptr, buffer, __size_buffer);ptr += __size_buffer;
1418
1419 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1420 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1421
1422
1423 GLint retval;
1424 stream->readback(&retval, 4);
1425 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1426 if (useChecksum) {
1427 unsigned char *checksumBufPtr = NULL;
1428 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1429 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1430 stream->readback(checksumBufPtr, checksumSize);
1431 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1432 ALOGE("rcCompose: GL communication error, please report this issue to b.android.com.\n");
1433 abort();
1434 }
1435 }
1436 return retval;
1437 }
1438
rcCreateDisplay_enc(void * self,uint32_t * displayId)1439 int rcCreateDisplay_enc(void *self , uint32_t* displayId)
1440 {
1441
1442 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1443 IOStream *stream = ctx->m_stream;
1444 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1445 bool useChecksum = checksumCalculator->getVersion() > 0;
1446
1447 const unsigned int __size_displayId = sizeof(uint32_t);
1448 unsigned char *ptr;
1449 unsigned char *buf;
1450 const size_t sizeWithoutChecksum = 8 + 0 + 1*4;
1451 const size_t checksumSize = checksumCalculator->checksumByteSize();
1452 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1453 buf = stream->alloc(totalSize);
1454 ptr = buf;
1455 int tmp = OP_rcCreateDisplay;memcpy(ptr, &tmp, 4); ptr += 4;
1456 memcpy(ptr, &totalSize, 4); ptr += 4;
1457
1458 *(unsigned int *)(ptr) = __size_displayId; ptr += 4;
1459
1460 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1461 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1462
1463 stream->readback(displayId, __size_displayId);
1464 if (useChecksum) checksumCalculator->addBuffer(displayId, __size_displayId);
1465
1466 int retval;
1467 stream->readback(&retval, 4);
1468 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1469 if (useChecksum) {
1470 unsigned char *checksumBufPtr = NULL;
1471 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1472 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1473 stream->readback(checksumBufPtr, checksumSize);
1474 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1475 ALOGE("rcCreateDisplay: GL communication error, please report this issue to b.android.com.\n");
1476 abort();
1477 }
1478 }
1479 return retval;
1480 }
1481
rcDestroyDisplay_enc(void * self,uint32_t displayId)1482 int rcDestroyDisplay_enc(void *self , uint32_t displayId)
1483 {
1484
1485 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1486 IOStream *stream = ctx->m_stream;
1487 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1488 bool useChecksum = checksumCalculator->getVersion() > 0;
1489
1490 unsigned char *ptr;
1491 unsigned char *buf;
1492 const size_t sizeWithoutChecksum = 8 + 4;
1493 const size_t checksumSize = checksumCalculator->checksumByteSize();
1494 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1495 buf = stream->alloc(totalSize);
1496 ptr = buf;
1497 int tmp = OP_rcDestroyDisplay;memcpy(ptr, &tmp, 4); ptr += 4;
1498 memcpy(ptr, &totalSize, 4); ptr += 4;
1499
1500 memcpy(ptr, &displayId, 4); ptr += 4;
1501
1502 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1503 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1504
1505
1506 int retval;
1507 stream->readback(&retval, 4);
1508 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1509 if (useChecksum) {
1510 unsigned char *checksumBufPtr = NULL;
1511 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1512 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1513 stream->readback(checksumBufPtr, checksumSize);
1514 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1515 ALOGE("rcDestroyDisplay: GL communication error, please report this issue to b.android.com.\n");
1516 abort();
1517 }
1518 }
1519 return retval;
1520 }
1521
rcSetDisplayColorBuffer_enc(void * self,uint32_t displayId,uint32_t colorBuffer)1522 int rcSetDisplayColorBuffer_enc(void *self , uint32_t displayId, uint32_t colorBuffer)
1523 {
1524
1525 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1526 IOStream *stream = ctx->m_stream;
1527 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1528 bool useChecksum = checksumCalculator->getVersion() > 0;
1529
1530 unsigned char *ptr;
1531 unsigned char *buf;
1532 const size_t sizeWithoutChecksum = 8 + 4 + 4;
1533 const size_t checksumSize = checksumCalculator->checksumByteSize();
1534 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1535 buf = stream->alloc(totalSize);
1536 ptr = buf;
1537 int tmp = OP_rcSetDisplayColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
1538 memcpy(ptr, &totalSize, 4); ptr += 4;
1539
1540 memcpy(ptr, &displayId, 4); ptr += 4;
1541 memcpy(ptr, &colorBuffer, 4); ptr += 4;
1542
1543 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1544 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1545
1546
1547 int retval;
1548 stream->readback(&retval, 4);
1549 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1550 if (useChecksum) {
1551 unsigned char *checksumBufPtr = NULL;
1552 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1553 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1554 stream->readback(checksumBufPtr, checksumSize);
1555 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1556 ALOGE("rcSetDisplayColorBuffer: GL communication error, please report this issue to b.android.com.\n");
1557 abort();
1558 }
1559 }
1560 return retval;
1561 }
1562
rcGetDisplayColorBuffer_enc(void * self,uint32_t displayId,uint32_t * colorBuffer)1563 int rcGetDisplayColorBuffer_enc(void *self , uint32_t displayId, uint32_t* colorBuffer)
1564 {
1565
1566 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1567 IOStream *stream = ctx->m_stream;
1568 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1569 bool useChecksum = checksumCalculator->getVersion() > 0;
1570
1571 const unsigned int __size_colorBuffer = sizeof(uint32_t);
1572 unsigned char *ptr;
1573 unsigned char *buf;
1574 const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
1575 const size_t checksumSize = checksumCalculator->checksumByteSize();
1576 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1577 buf = stream->alloc(totalSize);
1578 ptr = buf;
1579 int tmp = OP_rcGetDisplayColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
1580 memcpy(ptr, &totalSize, 4); ptr += 4;
1581
1582 memcpy(ptr, &displayId, 4); ptr += 4;
1583 *(unsigned int *)(ptr) = __size_colorBuffer; ptr += 4;
1584
1585 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1586 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1587
1588 stream->readback(colorBuffer, __size_colorBuffer);
1589 if (useChecksum) checksumCalculator->addBuffer(colorBuffer, __size_colorBuffer);
1590
1591 int retval;
1592 stream->readback(&retval, 4);
1593 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1594 if (useChecksum) {
1595 unsigned char *checksumBufPtr = NULL;
1596 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1597 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1598 stream->readback(checksumBufPtr, checksumSize);
1599 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1600 ALOGE("rcGetDisplayColorBuffer: GL communication error, please report this issue to b.android.com.\n");
1601 abort();
1602 }
1603 }
1604 return retval;
1605 }
1606
rcGetColorBufferDisplay_enc(void * self,uint32_t colorBuffer,uint32_t * displayId)1607 int rcGetColorBufferDisplay_enc(void *self , uint32_t colorBuffer, uint32_t* displayId)
1608 {
1609
1610 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1611 IOStream *stream = ctx->m_stream;
1612 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1613 bool useChecksum = checksumCalculator->getVersion() > 0;
1614
1615 const unsigned int __size_displayId = sizeof(uint32_t);
1616 unsigned char *ptr;
1617 unsigned char *buf;
1618 const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
1619 const size_t checksumSize = checksumCalculator->checksumByteSize();
1620 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1621 buf = stream->alloc(totalSize);
1622 ptr = buf;
1623 int tmp = OP_rcGetColorBufferDisplay;memcpy(ptr, &tmp, 4); ptr += 4;
1624 memcpy(ptr, &totalSize, 4); ptr += 4;
1625
1626 memcpy(ptr, &colorBuffer, 4); ptr += 4;
1627 *(unsigned int *)(ptr) = __size_displayId; ptr += 4;
1628
1629 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1630 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1631
1632 stream->readback(displayId, __size_displayId);
1633 if (useChecksum) checksumCalculator->addBuffer(displayId, __size_displayId);
1634
1635 int retval;
1636 stream->readback(&retval, 4);
1637 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1638 if (useChecksum) {
1639 unsigned char *checksumBufPtr = NULL;
1640 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1641 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1642 stream->readback(checksumBufPtr, checksumSize);
1643 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1644 ALOGE("rcGetColorBufferDisplay: GL communication error, please report this issue to b.android.com.\n");
1645 abort();
1646 }
1647 }
1648 return retval;
1649 }
1650
rcGetDisplayPose_enc(void * self,uint32_t displayId,GLint * x,GLint * y,uint32_t * w,uint32_t * h)1651 int rcGetDisplayPose_enc(void *self , uint32_t displayId, GLint* x, GLint* y, uint32_t* w, uint32_t* h)
1652 {
1653
1654 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1655 IOStream *stream = ctx->m_stream;
1656 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1657 bool useChecksum = checksumCalculator->getVersion() > 0;
1658
1659 const unsigned int __size_x = sizeof(int32_t);
1660 const unsigned int __size_y = sizeof(int32_t);
1661 const unsigned int __size_w = sizeof(uint32_t);
1662 const unsigned int __size_h = sizeof(uint32_t);
1663 unsigned char *ptr;
1664 unsigned char *buf;
1665 const size_t sizeWithoutChecksum = 8 + 4 + 0 + 0 + 0 + 0 + 4*4;
1666 const size_t checksumSize = checksumCalculator->checksumByteSize();
1667 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1668 buf = stream->alloc(totalSize);
1669 ptr = buf;
1670 int tmp = OP_rcGetDisplayPose;memcpy(ptr, &tmp, 4); ptr += 4;
1671 memcpy(ptr, &totalSize, 4); ptr += 4;
1672
1673 memcpy(ptr, &displayId, 4); ptr += 4;
1674 *(unsigned int *)(ptr) = __size_x; ptr += 4;
1675 *(unsigned int *)(ptr) = __size_y; ptr += 4;
1676 *(unsigned int *)(ptr) = __size_w; ptr += 4;
1677 *(unsigned int *)(ptr) = __size_h; ptr += 4;
1678
1679 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1680 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1681
1682 stream->readback(x, __size_x);
1683 if (useChecksum) checksumCalculator->addBuffer(x, __size_x);
1684 stream->readback(y, __size_y);
1685 if (useChecksum) checksumCalculator->addBuffer(y, __size_y);
1686 stream->readback(w, __size_w);
1687 if (useChecksum) checksumCalculator->addBuffer(w, __size_w);
1688 stream->readback(h, __size_h);
1689 if (useChecksum) checksumCalculator->addBuffer(h, __size_h);
1690
1691 int retval;
1692 stream->readback(&retval, 4);
1693 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1694 if (useChecksum) {
1695 unsigned char *checksumBufPtr = NULL;
1696 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1697 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1698 stream->readback(checksumBufPtr, checksumSize);
1699 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1700 ALOGE("rcGetDisplayPose: GL communication error, please report this issue to b.android.com.\n");
1701 abort();
1702 }
1703 }
1704 return retval;
1705 }
1706
rcSetDisplayPose_enc(void * self,uint32_t displayId,GLint x,GLint y,uint32_t w,uint32_t h)1707 int rcSetDisplayPose_enc(void *self , uint32_t displayId, GLint x, GLint y, uint32_t w, uint32_t h)
1708 {
1709
1710 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1711 IOStream *stream = ctx->m_stream;
1712 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1713 bool useChecksum = checksumCalculator->getVersion() > 0;
1714
1715 unsigned char *ptr;
1716 unsigned char *buf;
1717 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
1718 const size_t checksumSize = checksumCalculator->checksumByteSize();
1719 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1720 buf = stream->alloc(totalSize);
1721 ptr = buf;
1722 int tmp = OP_rcSetDisplayPose;memcpy(ptr, &tmp, 4); ptr += 4;
1723 memcpy(ptr, &totalSize, 4); ptr += 4;
1724
1725 memcpy(ptr, &displayId, 4); ptr += 4;
1726 memcpy(ptr, &x, 4); ptr += 4;
1727 memcpy(ptr, &y, 4); ptr += 4;
1728 memcpy(ptr, &w, 4); ptr += 4;
1729 memcpy(ptr, &h, 4); ptr += 4;
1730
1731 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1732 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1733
1734
1735 int retval;
1736 stream->readback(&retval, 4);
1737 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1738 if (useChecksum) {
1739 unsigned char *checksumBufPtr = NULL;
1740 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1741 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1742 stream->readback(checksumBufPtr, checksumSize);
1743 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1744 ALOGE("rcSetDisplayPose: GL communication error, please report this issue to b.android.com.\n");
1745 abort();
1746 }
1747 }
1748 return retval;
1749 }
1750
rcSetColorBufferVulkanMode_enc(void * self,uint32_t colorBuffer,uint32_t mode)1751 GLint rcSetColorBufferVulkanMode_enc(void *self , uint32_t colorBuffer, uint32_t mode)
1752 {
1753
1754 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1755 IOStream *stream = ctx->m_stream;
1756 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1757 bool useChecksum = checksumCalculator->getVersion() > 0;
1758
1759 unsigned char *ptr;
1760 unsigned char *buf;
1761 const size_t sizeWithoutChecksum = 8 + 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_rcSetColorBufferVulkanMode;memcpy(ptr, &tmp, 4); ptr += 4;
1767 memcpy(ptr, &totalSize, 4); ptr += 4;
1768
1769 memcpy(ptr, &colorBuffer, 4); ptr += 4;
1770 memcpy(ptr, &mode, 4); ptr += 4;
1771
1772 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1773 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1774
1775
1776 GLint retval;
1777 stream->readback(&retval, 4);
1778 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1779 if (useChecksum) {
1780 unsigned char *checksumBufPtr = NULL;
1781 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1782 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1783 stream->readback(checksumBufPtr, checksumSize);
1784 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1785 ALOGE("rcSetColorBufferVulkanMode: GL communication error, please report this issue to b.android.com.\n");
1786 abort();
1787 }
1788 }
1789 return retval;
1790 }
1791
rcReadColorBufferYUV_enc(void * self,uint32_t colorbuffer,GLint x,GLint y,GLint width,GLint height,void * pixels,uint32_t pixels_size)1792 void rcReadColorBufferYUV_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, void* pixels, uint32_t pixels_size)
1793 {
1794
1795 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1796 IOStream *stream = ctx->m_stream;
1797 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1798 bool useChecksum = checksumCalculator->getVersion() > 0;
1799
1800 const unsigned int __size_pixels = pixels_size;
1801 unsigned char *ptr;
1802 unsigned char *buf;
1803 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 0 + 4 + 1*4;
1804 const size_t checksumSize = checksumCalculator->checksumByteSize();
1805 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1806 buf = stream->alloc(totalSize);
1807 ptr = buf;
1808 int tmp = OP_rcReadColorBufferYUV;memcpy(ptr, &tmp, 4); ptr += 4;
1809 memcpy(ptr, &totalSize, 4); ptr += 4;
1810
1811 memcpy(ptr, &colorbuffer, 4); ptr += 4;
1812 memcpy(ptr, &x, 4); ptr += 4;
1813 memcpy(ptr, &y, 4); ptr += 4;
1814 memcpy(ptr, &width, 4); ptr += 4;
1815 memcpy(ptr, &height, 4); ptr += 4;
1816 *(unsigned int *)(ptr) = __size_pixels; ptr += 4;
1817 memcpy(ptr, &pixels_size, 4); ptr += 4;
1818
1819 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1820 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1821
1822 stream->readback(pixels, __size_pixels);
1823 if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
1824 if (useChecksum) {
1825 unsigned char *checksumBufPtr = NULL;
1826 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1827 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1828 stream->readback(checksumBufPtr, checksumSize);
1829 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1830 ALOGE("rcReadColorBufferYUV: GL communication error, please report this issue to b.android.com.\n");
1831 abort();
1832 }
1833 }
1834 }
1835
rcIsSyncSignaled_enc(void * self,uint64_t sync)1836 int rcIsSyncSignaled_enc(void *self , uint64_t sync)
1837 {
1838
1839 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1840 IOStream *stream = ctx->m_stream;
1841 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1842 bool useChecksum = checksumCalculator->getVersion() > 0;
1843
1844 unsigned char *ptr;
1845 unsigned char *buf;
1846 const size_t sizeWithoutChecksum = 8 + 8;
1847 const size_t checksumSize = checksumCalculator->checksumByteSize();
1848 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1849 buf = stream->alloc(totalSize);
1850 ptr = buf;
1851 int tmp = OP_rcIsSyncSignaled;memcpy(ptr, &tmp, 4); ptr += 4;
1852 memcpy(ptr, &totalSize, 4); ptr += 4;
1853
1854 memcpy(ptr, &sync, 8); ptr += 8;
1855
1856 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1857 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1858
1859
1860 int retval;
1861 stream->readback(&retval, 4);
1862 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1863 if (useChecksum) {
1864 unsigned char *checksumBufPtr = NULL;
1865 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1866 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1867 stream->readback(checksumBufPtr, checksumSize);
1868 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1869 ALOGE("rcIsSyncSignaled: GL communication error, please report this issue to b.android.com.\n");
1870 abort();
1871 }
1872 }
1873 return retval;
1874 }
1875
rcCreateColorBufferWithHandle_enc(void * self,uint32_t width,uint32_t height,GLenum internalFormat,uint32_t handle)1876 void rcCreateColorBufferWithHandle_enc(void *self , uint32_t width, uint32_t height, GLenum internalFormat, uint32_t handle)
1877 {
1878
1879 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1880 IOStream *stream = ctx->m_stream;
1881 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1882 bool useChecksum = checksumCalculator->getVersion() > 0;
1883
1884 unsigned char *ptr;
1885 unsigned char *buf;
1886 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
1887 const size_t checksumSize = checksumCalculator->checksumByteSize();
1888 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1889 buf = stream->alloc(totalSize);
1890 ptr = buf;
1891 int tmp = OP_rcCreateColorBufferWithHandle;memcpy(ptr, &tmp, 4); ptr += 4;
1892 memcpy(ptr, &totalSize, 4); ptr += 4;
1893
1894 memcpy(ptr, &width, 4); ptr += 4;
1895 memcpy(ptr, &height, 4); ptr += 4;
1896 memcpy(ptr, &internalFormat, 4); ptr += 4;
1897 memcpy(ptr, &handle, 4); ptr += 4;
1898
1899 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1900 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1901
1902 }
1903
rcCreateBuffer_enc(void * self,uint32_t size)1904 uint32_t rcCreateBuffer_enc(void *self , uint32_t size)
1905 {
1906
1907 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1908 IOStream *stream = ctx->m_stream;
1909 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1910 bool useChecksum = checksumCalculator->getVersion() > 0;
1911
1912 unsigned char *ptr;
1913 unsigned char *buf;
1914 const size_t sizeWithoutChecksum = 8 + 4;
1915 const size_t checksumSize = checksumCalculator->checksumByteSize();
1916 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1917 buf = stream->alloc(totalSize);
1918 ptr = buf;
1919 int tmp = OP_rcCreateBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
1920 memcpy(ptr, &totalSize, 4); ptr += 4;
1921
1922 memcpy(ptr, &size, 4); ptr += 4;
1923
1924 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1925 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1926
1927
1928 uint32_t retval;
1929 stream->readback(&retval, 4);
1930 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1931 if (useChecksum) {
1932 unsigned char *checksumBufPtr = NULL;
1933 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1934 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1935 stream->readback(checksumBufPtr, checksumSize);
1936 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1937 ALOGE("rcCreateBuffer: GL communication error, please report this issue to b.android.com.\n");
1938 abort();
1939 }
1940 }
1941 return retval;
1942 }
1943
rcCloseBuffer_enc(void * self,uint32_t buffer)1944 void rcCloseBuffer_enc(void *self , uint32_t buffer)
1945 {
1946
1947 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1948 IOStream *stream = ctx->m_stream;
1949 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1950 bool useChecksum = checksumCalculator->getVersion() > 0;
1951
1952 unsigned char *ptr;
1953 unsigned char *buf;
1954 const size_t sizeWithoutChecksum = 8 + 4;
1955 const size_t checksumSize = checksumCalculator->checksumByteSize();
1956 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1957 buf = stream->alloc(totalSize);
1958 ptr = buf;
1959 int tmp = OP_rcCloseBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
1960 memcpy(ptr, &totalSize, 4); ptr += 4;
1961
1962 memcpy(ptr, &buffer, 4); ptr += 4;
1963
1964 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1965 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1966
1967 }
1968
1969 } // namespace
1970
renderControl_encoder_context_t(IOStream * stream,ChecksumCalculator * checksumCalculator)1971 renderControl_encoder_context_t::renderControl_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator)
1972 {
1973 m_stream = stream;
1974 m_checksumCalculator = checksumCalculator;
1975
1976 this->rcGetRendererVersion = &rcGetRendererVersion_enc;
1977 this->rcGetEGLVersion = &rcGetEGLVersion_enc;
1978 this->rcQueryEGLString = &rcQueryEGLString_enc;
1979 this->rcGetGLString = &rcGetGLString_enc;
1980 this->rcGetNumConfigs = &rcGetNumConfigs_enc;
1981 this->rcGetConfigs = &rcGetConfigs_enc;
1982 this->rcChooseConfig = &rcChooseConfig_enc;
1983 this->rcGetFBParam = &rcGetFBParam_enc;
1984 this->rcCreateContext = &rcCreateContext_enc;
1985 this->rcDestroyContext = &rcDestroyContext_enc;
1986 this->rcCreateWindowSurface = &rcCreateWindowSurface_enc;
1987 this->rcDestroyWindowSurface = &rcDestroyWindowSurface_enc;
1988 this->rcCreateColorBuffer = &rcCreateColorBuffer_enc;
1989 this->rcOpenColorBuffer = &rcOpenColorBuffer_enc;
1990 this->rcCloseColorBuffer = &rcCloseColorBuffer_enc;
1991 this->rcSetWindowColorBuffer = &rcSetWindowColorBuffer_enc;
1992 this->rcFlushWindowColorBuffer = &rcFlushWindowColorBuffer_enc;
1993 this->rcMakeCurrent = &rcMakeCurrent_enc;
1994 this->rcFBPost = &rcFBPost_enc;
1995 this->rcFBSetSwapInterval = &rcFBSetSwapInterval_enc;
1996 this->rcBindTexture = &rcBindTexture_enc;
1997 this->rcBindRenderbuffer = &rcBindRenderbuffer_enc;
1998 this->rcColorBufferCacheFlush = &rcColorBufferCacheFlush_enc;
1999 this->rcReadColorBuffer = &rcReadColorBuffer_enc;
2000 this->rcUpdateColorBuffer = &rcUpdateColorBuffer_enc;
2001 this->rcOpenColorBuffer2 = &rcOpenColorBuffer2_enc;
2002 this->rcCreateClientImage = &rcCreateClientImage_enc;
2003 this->rcDestroyClientImage = &rcDestroyClientImage_enc;
2004 this->rcSelectChecksumHelper = &rcSelectChecksumHelper_enc;
2005 this->rcCreateSyncKHR = &rcCreateSyncKHR_enc;
2006 this->rcClientWaitSyncKHR = &rcClientWaitSyncKHR_enc;
2007 this->rcFlushWindowColorBufferAsync = &rcFlushWindowColorBufferAsync_enc;
2008 this->rcDestroySyncKHR = &rcDestroySyncKHR_enc;
2009 this->rcSetPuid = &rcSetPuid_enc;
2010 this->rcUpdateColorBufferDMA = &rcUpdateColorBufferDMA_enc;
2011 this->rcCreateColorBufferDMA = &rcCreateColorBufferDMA_enc;
2012 this->rcWaitSyncKHR = &rcWaitSyncKHR_enc;
2013 this->rcCompose = &rcCompose_enc;
2014 this->rcCreateDisplay = &rcCreateDisplay_enc;
2015 this->rcDestroyDisplay = &rcDestroyDisplay_enc;
2016 this->rcSetDisplayColorBuffer = &rcSetDisplayColorBuffer_enc;
2017 this->rcGetDisplayColorBuffer = &rcGetDisplayColorBuffer_enc;
2018 this->rcGetColorBufferDisplay = &rcGetColorBufferDisplay_enc;
2019 this->rcGetDisplayPose = &rcGetDisplayPose_enc;
2020 this->rcSetDisplayPose = &rcSetDisplayPose_enc;
2021 this->rcSetColorBufferVulkanMode = &rcSetColorBufferVulkanMode_enc;
2022 this->rcReadColorBufferYUV = &rcReadColorBufferYUV_enc;
2023 this->rcIsSyncSignaled = &rcIsSyncSignaled_enc;
2024 this->rcCreateColorBufferWithHandle = &rcCreateColorBufferWithHandle_enc;
2025 this->rcCreateBuffer = &rcCreateBuffer_enc;
2026 this->rcCloseBuffer = &rcCloseBuffer_enc;
2027 }
2028
2029