1 // Generated Code - DO NOT EDIT !!
2 // generated by 'emugen'
3
4
5 #include <vector>
6 #include <string.h>
7 #include "renderControl_opcodes.h"
8
9 #include "renderControl_enc.h"
10
11
12 #include <stdio.h>
13
14 namespace {
15
enc_unsupported()16 void enc_unsupported()
17 {
18 ALOGE("Function is unsupported\n");
19 }
20
rcGetRendererVersion_enc(void * self)21 GLint rcGetRendererVersion_enc(void *self )
22 {
23
24 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
25 IOStream *stream = ctx->m_stream;
26 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
27 bool useChecksum = checksumCalculator->getVersion() > 0;
28
29 unsigned char *ptr;
30 unsigned char *buf;
31 const size_t sizeWithoutChecksum = 8;
32 const size_t checksumSize = checksumCalculator->checksumByteSize();
33 const size_t totalSize = sizeWithoutChecksum + checksumSize;
34 buf = stream->alloc(totalSize);
35 ptr = buf;
36 int tmp = OP_rcGetRendererVersion;memcpy(ptr, &tmp, 4); ptr += 4;
37 memcpy(ptr, &totalSize, 4); ptr += 4;
38
39
40 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
41 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
42
43
44 GLint retval;
45 stream->readback(&retval, 4);
46 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
47 if (useChecksum) {
48 unsigned char *checksumBufPtr = NULL;
49 std::vector<unsigned char> checksumBuf(checksumSize);
50 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
51 stream->readback(checksumBufPtr, checksumSize);
52 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
53 ALOGE("rcGetRendererVersion: GL communication error, please report this issue to b.android.com.\n");
54 abort();
55 }
56 }
57 return retval;
58 }
59
rcGetEGLVersion_enc(void * self,EGLint * major,EGLint * minor)60 EGLint rcGetEGLVersion_enc(void *self , EGLint* major, EGLint* minor)
61 {
62
63 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
64 IOStream *stream = ctx->m_stream;
65 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
66 bool useChecksum = checksumCalculator->getVersion() > 0;
67
68 const unsigned int __size_major = sizeof(EGLint);
69 const unsigned int __size_minor = sizeof(EGLint);
70 unsigned char *ptr;
71 unsigned char *buf;
72 const size_t sizeWithoutChecksum = 8 + __size_major + __size_minor + 2*4;
73 const size_t checksumSize = checksumCalculator->checksumByteSize();
74 const size_t totalSize = sizeWithoutChecksum + checksumSize;
75 buf = stream->alloc(totalSize);
76 ptr = buf;
77 int tmp = OP_rcGetEGLVersion;memcpy(ptr, &tmp, 4); ptr += 4;
78 memcpy(ptr, &totalSize, 4); ptr += 4;
79
80 *(unsigned int *)(ptr) = __size_major; ptr += 4;
81 *(unsigned int *)(ptr) = __size_minor; ptr += 4;
82
83 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
84 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
85
86 stream->readback(major, __size_major);
87 if (useChecksum) checksumCalculator->addBuffer(major, __size_major);
88 stream->readback(minor, __size_minor);
89 if (useChecksum) checksumCalculator->addBuffer(minor, __size_minor);
90
91 EGLint retval;
92 stream->readback(&retval, 4);
93 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
94 if (useChecksum) {
95 unsigned char *checksumBufPtr = NULL;
96 std::vector<unsigned char> checksumBuf(checksumSize);
97 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
98 stream->readback(checksumBufPtr, checksumSize);
99 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
100 ALOGE("rcGetEGLVersion: GL communication error, please report this issue to b.android.com.\n");
101 abort();
102 }
103 }
104 return retval;
105 }
106
rcQueryEGLString_enc(void * self,EGLenum name,void * buffer,EGLint bufferSize)107 EGLint rcQueryEGLString_enc(void *self , EGLenum name, void* buffer, EGLint bufferSize)
108 {
109
110 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
111 IOStream *stream = ctx->m_stream;
112 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
113 bool useChecksum = checksumCalculator->getVersion() > 0;
114
115 const unsigned int __size_buffer = bufferSize;
116 unsigned char *ptr;
117 unsigned char *buf;
118 const size_t sizeWithoutChecksum = 8 + 4 + __size_buffer + 4 + 1*4;
119 const size_t checksumSize = checksumCalculator->checksumByteSize();
120 const size_t totalSize = sizeWithoutChecksum + checksumSize;
121 buf = stream->alloc(totalSize);
122 ptr = buf;
123 int tmp = OP_rcQueryEGLString;memcpy(ptr, &tmp, 4); ptr += 4;
124 memcpy(ptr, &totalSize, 4); ptr += 4;
125
126 memcpy(ptr, &name, 4); ptr += 4;
127 *(unsigned int *)(ptr) = __size_buffer; ptr += 4;
128 memcpy(ptr, &bufferSize, 4); ptr += 4;
129
130 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
131 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
132
133 stream->readback(buffer, __size_buffer);
134 if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer);
135
136 EGLint retval;
137 stream->readback(&retval, 4);
138 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
139 if (useChecksum) {
140 unsigned char *checksumBufPtr = NULL;
141 std::vector<unsigned char> checksumBuf(checksumSize);
142 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
143 stream->readback(checksumBufPtr, checksumSize);
144 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
145 ALOGE("rcQueryEGLString: GL communication error, please report this issue to b.android.com.\n");
146 abort();
147 }
148 }
149 return retval;
150 }
151
rcGetGLString_enc(void * self,EGLenum name,void * buffer,EGLint bufferSize)152 EGLint rcGetGLString_enc(void *self , EGLenum name, void* buffer, EGLint bufferSize)
153 {
154
155 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
156 IOStream *stream = ctx->m_stream;
157 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
158 bool useChecksum = checksumCalculator->getVersion() > 0;
159
160 const unsigned int __size_buffer = bufferSize;
161 unsigned char *ptr;
162 unsigned char *buf;
163 const size_t sizeWithoutChecksum = 8 + 4 + __size_buffer + 4 + 1*4;
164 const size_t checksumSize = checksumCalculator->checksumByteSize();
165 const size_t totalSize = sizeWithoutChecksum + checksumSize;
166 buf = stream->alloc(totalSize);
167 ptr = buf;
168 int tmp = OP_rcGetGLString;memcpy(ptr, &tmp, 4); ptr += 4;
169 memcpy(ptr, &totalSize, 4); ptr += 4;
170
171 memcpy(ptr, &name, 4); ptr += 4;
172 *(unsigned int *)(ptr) = __size_buffer; ptr += 4;
173 memcpy(ptr, &bufferSize, 4); ptr += 4;
174
175 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
176 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
177
178 stream->readback(buffer, __size_buffer);
179 if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer);
180
181 EGLint retval;
182 stream->readback(&retval, 4);
183 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
184 if (useChecksum) {
185 unsigned char *checksumBufPtr = NULL;
186 std::vector<unsigned char> checksumBuf(checksumSize);
187 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
188 stream->readback(checksumBufPtr, checksumSize);
189 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
190 ALOGE("rcGetGLString: GL communication error, please report this issue to b.android.com.\n");
191 abort();
192 }
193 }
194 return retval;
195 }
196
rcGetNumConfigs_enc(void * self,uint32_t * numAttribs)197 EGLint rcGetNumConfigs_enc(void *self , uint32_t* numAttribs)
198 {
199
200 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
201 IOStream *stream = ctx->m_stream;
202 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
203 bool useChecksum = checksumCalculator->getVersion() > 0;
204
205 const unsigned int __size_numAttribs = sizeof(uint32_t);
206 unsigned char *ptr;
207 unsigned char *buf;
208 const size_t sizeWithoutChecksum = 8 + __size_numAttribs + 1*4;
209 const size_t checksumSize = checksumCalculator->checksumByteSize();
210 const size_t totalSize = sizeWithoutChecksum + checksumSize;
211 buf = stream->alloc(totalSize);
212 ptr = buf;
213 int tmp = OP_rcGetNumConfigs;memcpy(ptr, &tmp, 4); ptr += 4;
214 memcpy(ptr, &totalSize, 4); ptr += 4;
215
216 *(unsigned int *)(ptr) = __size_numAttribs; ptr += 4;
217
218 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
219 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
220
221 stream->readback(numAttribs, __size_numAttribs);
222 if (useChecksum) checksumCalculator->addBuffer(numAttribs, __size_numAttribs);
223
224 EGLint retval;
225 stream->readback(&retval, 4);
226 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
227 if (useChecksum) {
228 unsigned char *checksumBufPtr = NULL;
229 std::vector<unsigned char> checksumBuf(checksumSize);
230 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
231 stream->readback(checksumBufPtr, checksumSize);
232 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
233 ALOGE("rcGetNumConfigs: GL communication error, please report this issue to b.android.com.\n");
234 abort();
235 }
236 }
237 return retval;
238 }
239
rcGetConfigs_enc(void * self,uint32_t bufSize,GLuint * buffer)240 EGLint rcGetConfigs_enc(void *self , uint32_t bufSize, GLuint* buffer)
241 {
242
243 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
244 IOStream *stream = ctx->m_stream;
245 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
246 bool useChecksum = checksumCalculator->getVersion() > 0;
247
248 const unsigned int __size_buffer = bufSize;
249 unsigned char *ptr;
250 unsigned char *buf;
251 const size_t sizeWithoutChecksum = 8 + 4 + __size_buffer + 1*4;
252 const size_t checksumSize = checksumCalculator->checksumByteSize();
253 const size_t totalSize = sizeWithoutChecksum + checksumSize;
254 buf = stream->alloc(totalSize);
255 ptr = buf;
256 int tmp = OP_rcGetConfigs;memcpy(ptr, &tmp, 4); ptr += 4;
257 memcpy(ptr, &totalSize, 4); ptr += 4;
258
259 memcpy(ptr, &bufSize, 4); ptr += 4;
260 *(unsigned int *)(ptr) = __size_buffer; ptr += 4;
261
262 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
263 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
264
265 stream->readback(buffer, __size_buffer);
266 if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer);
267
268 EGLint retval;
269 stream->readback(&retval, 4);
270 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
271 if (useChecksum) {
272 unsigned char *checksumBufPtr = NULL;
273 std::vector<unsigned char> checksumBuf(checksumSize);
274 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
275 stream->readback(checksumBufPtr, checksumSize);
276 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
277 ALOGE("rcGetConfigs: GL communication error, please report this issue to b.android.com.\n");
278 abort();
279 }
280 }
281 return retval;
282 }
283
rcChooseConfig_enc(void * self,EGLint * attribs,uint32_t attribs_size,uint32_t * configs,uint32_t configs_size)284 EGLint rcChooseConfig_enc(void *self , EGLint* attribs, uint32_t attribs_size, uint32_t* configs, uint32_t configs_size)
285 {
286
287 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
288 IOStream *stream = ctx->m_stream;
289 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
290 bool useChecksum = checksumCalculator->getVersion() > 0;
291
292 const unsigned int __size_attribs = attribs_size;
293 const unsigned int __size_configs = ((configs != NULL) ? configs_size*sizeof(uint32_t) : 0);
294 unsigned char *ptr;
295 unsigned char *buf;
296 const size_t sizeWithoutChecksum = 8 + __size_attribs + 4 + __size_configs + 4 + 2*4;
297 const size_t checksumSize = checksumCalculator->checksumByteSize();
298 const size_t totalSize = sizeWithoutChecksum + checksumSize;
299 buf = stream->alloc(totalSize);
300 ptr = buf;
301 int tmp = OP_rcChooseConfig;memcpy(ptr, &tmp, 4); ptr += 4;
302 memcpy(ptr, &totalSize, 4); ptr += 4;
303
304 *(unsigned int *)(ptr) = __size_attribs; ptr += 4;
305 memcpy(ptr, attribs, __size_attribs);ptr += __size_attribs;
306 memcpy(ptr, &attribs_size, 4); ptr += 4;
307 *(unsigned int *)(ptr) = __size_configs; ptr += 4;
308 memcpy(ptr, &configs_size, 4); ptr += 4;
309
310 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
311 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
312
313 if (configs != NULL) {
314 stream->readback(configs, __size_configs);
315 if (useChecksum) checksumCalculator->addBuffer(configs, __size_configs);
316 }
317
318 EGLint retval;
319 stream->readback(&retval, 4);
320 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
321 if (useChecksum) {
322 unsigned char *checksumBufPtr = NULL;
323 std::vector<unsigned char> checksumBuf(checksumSize);
324 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
325 stream->readback(checksumBufPtr, checksumSize);
326 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
327 ALOGE("rcChooseConfig: GL communication error, please report this issue to b.android.com.\n");
328 abort();
329 }
330 }
331 return retval;
332 }
333
rcGetFBParam_enc(void * self,EGLint param)334 EGLint rcGetFBParam_enc(void *self , EGLint param)
335 {
336
337 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
338 IOStream *stream = ctx->m_stream;
339 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
340 bool useChecksum = checksumCalculator->getVersion() > 0;
341
342 unsigned char *ptr;
343 unsigned char *buf;
344 const size_t sizeWithoutChecksum = 8 + 4;
345 const size_t checksumSize = checksumCalculator->checksumByteSize();
346 const size_t totalSize = sizeWithoutChecksum + checksumSize;
347 buf = stream->alloc(totalSize);
348 ptr = buf;
349 int tmp = OP_rcGetFBParam;memcpy(ptr, &tmp, 4); ptr += 4;
350 memcpy(ptr, &totalSize, 4); ptr += 4;
351
352 memcpy(ptr, ¶m, 4); ptr += 4;
353
354 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
355 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
356
357
358 EGLint retval;
359 stream->readback(&retval, 4);
360 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
361 if (useChecksum) {
362 unsigned char *checksumBufPtr = NULL;
363 std::vector<unsigned char> checksumBuf(checksumSize);
364 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
365 stream->readback(checksumBufPtr, checksumSize);
366 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
367 ALOGE("rcGetFBParam: GL communication error, please report this issue to b.android.com.\n");
368 abort();
369 }
370 }
371 return retval;
372 }
373
rcCreateContext_enc(void * self,uint32_t config,uint32_t share,uint32_t glVersion)374 uint32_t rcCreateContext_enc(void *self , uint32_t config, uint32_t share, uint32_t glVersion)
375 {
376
377 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
378 IOStream *stream = ctx->m_stream;
379 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
380 bool useChecksum = checksumCalculator->getVersion() > 0;
381
382 unsigned char *ptr;
383 unsigned char *buf;
384 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
385 const size_t checksumSize = checksumCalculator->checksumByteSize();
386 const size_t totalSize = sizeWithoutChecksum + checksumSize;
387 buf = stream->alloc(totalSize);
388 ptr = buf;
389 int tmp = OP_rcCreateContext;memcpy(ptr, &tmp, 4); ptr += 4;
390 memcpy(ptr, &totalSize, 4); ptr += 4;
391
392 memcpy(ptr, &config, 4); ptr += 4;
393 memcpy(ptr, &share, 4); ptr += 4;
394 memcpy(ptr, &glVersion, 4); ptr += 4;
395
396 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
397 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
398
399
400 uint32_t retval;
401 stream->readback(&retval, 4);
402 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
403 if (useChecksum) {
404 unsigned char *checksumBufPtr = NULL;
405 std::vector<unsigned char> checksumBuf(checksumSize);
406 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
407 stream->readback(checksumBufPtr, checksumSize);
408 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
409 ALOGE("rcCreateContext: GL communication error, please report this issue to b.android.com.\n");
410 abort();
411 }
412 }
413 return retval;
414 }
415
rcDestroyContext_enc(void * self,uint32_t context)416 void rcDestroyContext_enc(void *self , uint32_t context)
417 {
418
419 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
420 IOStream *stream = ctx->m_stream;
421 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
422 bool useChecksum = checksumCalculator->getVersion() > 0;
423
424 unsigned char *ptr;
425 unsigned char *buf;
426 const size_t sizeWithoutChecksum = 8 + 4;
427 const size_t checksumSize = checksumCalculator->checksumByteSize();
428 const size_t totalSize = sizeWithoutChecksum + checksumSize;
429 buf = stream->alloc(totalSize);
430 ptr = buf;
431 int tmp = OP_rcDestroyContext;memcpy(ptr, &tmp, 4); ptr += 4;
432 memcpy(ptr, &totalSize, 4); ptr += 4;
433
434 memcpy(ptr, &context, 4); ptr += 4;
435
436 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
437 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
438
439 }
440
rcCreateWindowSurface_enc(void * self,uint32_t config,uint32_t width,uint32_t height)441 uint32_t rcCreateWindowSurface_enc(void *self , uint32_t config, uint32_t width, uint32_t height)
442 {
443
444 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
445 IOStream *stream = ctx->m_stream;
446 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
447 bool useChecksum = checksumCalculator->getVersion() > 0;
448
449 unsigned char *ptr;
450 unsigned char *buf;
451 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
452 const size_t checksumSize = checksumCalculator->checksumByteSize();
453 const size_t totalSize = sizeWithoutChecksum + checksumSize;
454 buf = stream->alloc(totalSize);
455 ptr = buf;
456 int tmp = OP_rcCreateWindowSurface;memcpy(ptr, &tmp, 4); ptr += 4;
457 memcpy(ptr, &totalSize, 4); ptr += 4;
458
459 memcpy(ptr, &config, 4); ptr += 4;
460 memcpy(ptr, &width, 4); ptr += 4;
461 memcpy(ptr, &height, 4); ptr += 4;
462
463 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
464 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
465
466
467 uint32_t retval;
468 stream->readback(&retval, 4);
469 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
470 if (useChecksum) {
471 unsigned char *checksumBufPtr = NULL;
472 std::vector<unsigned char> checksumBuf(checksumSize);
473 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
474 stream->readback(checksumBufPtr, checksumSize);
475 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
476 ALOGE("rcCreateWindowSurface: GL communication error, please report this issue to b.android.com.\n");
477 abort();
478 }
479 }
480 return retval;
481 }
482
rcDestroyWindowSurface_enc(void * self,uint32_t windowSurface)483 void rcDestroyWindowSurface_enc(void *self , uint32_t windowSurface)
484 {
485
486 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
487 IOStream *stream = ctx->m_stream;
488 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
489 bool useChecksum = checksumCalculator->getVersion() > 0;
490
491 unsigned char *ptr;
492 unsigned char *buf;
493 const size_t sizeWithoutChecksum = 8 + 4;
494 const size_t checksumSize = checksumCalculator->checksumByteSize();
495 const size_t totalSize = sizeWithoutChecksum + checksumSize;
496 buf = stream->alloc(totalSize);
497 ptr = buf;
498 int tmp = OP_rcDestroyWindowSurface;memcpy(ptr, &tmp, 4); ptr += 4;
499 memcpy(ptr, &totalSize, 4); ptr += 4;
500
501 memcpy(ptr, &windowSurface, 4); ptr += 4;
502
503 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
504 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
505
506 }
507
rcCreateColorBuffer_enc(void * self,uint32_t width,uint32_t height,GLenum internalFormat)508 uint32_t rcCreateColorBuffer_enc(void *self , uint32_t width, uint32_t height, GLenum internalFormat)
509 {
510
511 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
512 IOStream *stream = ctx->m_stream;
513 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
514 bool useChecksum = checksumCalculator->getVersion() > 0;
515
516 unsigned char *ptr;
517 unsigned char *buf;
518 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
519 const size_t checksumSize = checksumCalculator->checksumByteSize();
520 const size_t totalSize = sizeWithoutChecksum + checksumSize;
521 buf = stream->alloc(totalSize);
522 ptr = buf;
523 int tmp = OP_rcCreateColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
524 memcpy(ptr, &totalSize, 4); ptr += 4;
525
526 memcpy(ptr, &width, 4); ptr += 4;
527 memcpy(ptr, &height, 4); ptr += 4;
528 memcpy(ptr, &internalFormat, 4); ptr += 4;
529
530 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
531 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
532
533
534 uint32_t retval;
535 stream->readback(&retval, 4);
536 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
537 if (useChecksum) {
538 unsigned char *checksumBufPtr = NULL;
539 std::vector<unsigned char> checksumBuf(checksumSize);
540 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
541 stream->readback(checksumBufPtr, checksumSize);
542 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
543 ALOGE("rcCreateColorBuffer: GL communication error, please report this issue to b.android.com.\n");
544 abort();
545 }
546 }
547 return retval;
548 }
549
rcOpenColorBuffer_enc(void * self,uint32_t colorbuffer)550 void rcOpenColorBuffer_enc(void *self , uint32_t colorbuffer)
551 {
552
553 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
554 IOStream *stream = ctx->m_stream;
555 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
556 bool useChecksum = checksumCalculator->getVersion() > 0;
557
558 unsigned char *ptr;
559 unsigned char *buf;
560 const size_t sizeWithoutChecksum = 8 + 4;
561 const size_t checksumSize = checksumCalculator->checksumByteSize();
562 const size_t totalSize = sizeWithoutChecksum + checksumSize;
563 buf = stream->alloc(totalSize);
564 ptr = buf;
565 int tmp = OP_rcOpenColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
566 memcpy(ptr, &totalSize, 4); ptr += 4;
567
568 memcpy(ptr, &colorbuffer, 4); ptr += 4;
569
570 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
571 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
572
573 }
574
rcCloseColorBuffer_enc(void * self,uint32_t colorbuffer)575 void rcCloseColorBuffer_enc(void *self , uint32_t colorbuffer)
576 {
577
578 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
579 IOStream *stream = ctx->m_stream;
580 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
581 bool useChecksum = checksumCalculator->getVersion() > 0;
582
583 unsigned char *ptr;
584 unsigned char *buf;
585 const size_t sizeWithoutChecksum = 8 + 4;
586 const size_t checksumSize = checksumCalculator->checksumByteSize();
587 const size_t totalSize = sizeWithoutChecksum + checksumSize;
588 buf = stream->alloc(totalSize);
589 ptr = buf;
590 int tmp = OP_rcCloseColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
591 memcpy(ptr, &totalSize, 4); ptr += 4;
592
593 memcpy(ptr, &colorbuffer, 4); ptr += 4;
594
595 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
596 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
597
598 stream->flush();
599 }
600
rcSetWindowColorBuffer_enc(void * self,uint32_t windowSurface,uint32_t colorBuffer)601 void rcSetWindowColorBuffer_enc(void *self , uint32_t windowSurface, uint32_t colorBuffer)
602 {
603
604 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
605 IOStream *stream = ctx->m_stream;
606 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
607 bool useChecksum = checksumCalculator->getVersion() > 0;
608
609 unsigned char *ptr;
610 unsigned char *buf;
611 const size_t sizeWithoutChecksum = 8 + 4 + 4;
612 const size_t checksumSize = checksumCalculator->checksumByteSize();
613 const size_t totalSize = sizeWithoutChecksum + checksumSize;
614 buf = stream->alloc(totalSize);
615 ptr = buf;
616 int tmp = OP_rcSetWindowColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
617 memcpy(ptr, &totalSize, 4); ptr += 4;
618
619 memcpy(ptr, &windowSurface, 4); ptr += 4;
620 memcpy(ptr, &colorBuffer, 4); ptr += 4;
621
622 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
623 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
624
625 }
626
rcFlushWindowColorBuffer_enc(void * self,uint32_t windowSurface)627 int rcFlushWindowColorBuffer_enc(void *self , uint32_t windowSurface)
628 {
629
630 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
631 IOStream *stream = ctx->m_stream;
632 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
633 bool useChecksum = checksumCalculator->getVersion() > 0;
634
635 unsigned char *ptr;
636 unsigned char *buf;
637 const size_t sizeWithoutChecksum = 8 + 4;
638 const size_t checksumSize = checksumCalculator->checksumByteSize();
639 const size_t totalSize = sizeWithoutChecksum + checksumSize;
640 buf = stream->alloc(totalSize);
641 ptr = buf;
642 int tmp = OP_rcFlushWindowColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
643 memcpy(ptr, &totalSize, 4); ptr += 4;
644
645 memcpy(ptr, &windowSurface, 4); ptr += 4;
646
647 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
648 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
649
650
651 int retval;
652 stream->readback(&retval, 4);
653 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
654 if (useChecksum) {
655 unsigned char *checksumBufPtr = NULL;
656 std::vector<unsigned char> checksumBuf(checksumSize);
657 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
658 stream->readback(checksumBufPtr, checksumSize);
659 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
660 ALOGE("rcFlushWindowColorBuffer: GL communication error, please report this issue to b.android.com.\n");
661 abort();
662 }
663 }
664 return retval;
665 }
666
rcMakeCurrent_enc(void * self,uint32_t context,uint32_t drawSurf,uint32_t readSurf)667 EGLint rcMakeCurrent_enc(void *self , uint32_t context, uint32_t drawSurf, uint32_t readSurf)
668 {
669
670 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
671 IOStream *stream = ctx->m_stream;
672 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
673 bool useChecksum = checksumCalculator->getVersion() > 0;
674
675 unsigned char *ptr;
676 unsigned char *buf;
677 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
678 const size_t checksumSize = checksumCalculator->checksumByteSize();
679 const size_t totalSize = sizeWithoutChecksum + checksumSize;
680 buf = stream->alloc(totalSize);
681 ptr = buf;
682 int tmp = OP_rcMakeCurrent;memcpy(ptr, &tmp, 4); ptr += 4;
683 memcpy(ptr, &totalSize, 4); ptr += 4;
684
685 memcpy(ptr, &context, 4); ptr += 4;
686 memcpy(ptr, &drawSurf, 4); ptr += 4;
687 memcpy(ptr, &readSurf, 4); ptr += 4;
688
689 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
690 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
691
692
693 EGLint retval;
694 stream->readback(&retval, 4);
695 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
696 if (useChecksum) {
697 unsigned char *checksumBufPtr = NULL;
698 std::vector<unsigned char> checksumBuf(checksumSize);
699 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
700 stream->readback(checksumBufPtr, checksumSize);
701 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
702 ALOGE("rcMakeCurrent: GL communication error, please report this issue to b.android.com.\n");
703 abort();
704 }
705 }
706 return retval;
707 }
708
rcFBPost_enc(void * self,uint32_t colorBuffer)709 void rcFBPost_enc(void *self , uint32_t colorBuffer)
710 {
711
712 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
713 IOStream *stream = ctx->m_stream;
714 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
715 bool useChecksum = checksumCalculator->getVersion() > 0;
716
717 unsigned char *ptr;
718 unsigned char *buf;
719 const size_t sizeWithoutChecksum = 8 + 4;
720 const size_t checksumSize = checksumCalculator->checksumByteSize();
721 const size_t totalSize = sizeWithoutChecksum + checksumSize;
722 buf = stream->alloc(totalSize);
723 ptr = buf;
724 int tmp = OP_rcFBPost;memcpy(ptr, &tmp, 4); ptr += 4;
725 memcpy(ptr, &totalSize, 4); ptr += 4;
726
727 memcpy(ptr, &colorBuffer, 4); ptr += 4;
728
729 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
730 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
731
732 }
733
rcFBSetSwapInterval_enc(void * self,EGLint interval)734 void rcFBSetSwapInterval_enc(void *self , EGLint interval)
735 {
736
737 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
738 IOStream *stream = ctx->m_stream;
739 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
740 bool useChecksum = checksumCalculator->getVersion() > 0;
741
742 unsigned char *ptr;
743 unsigned char *buf;
744 const size_t sizeWithoutChecksum = 8 + 4;
745 const size_t checksumSize = checksumCalculator->checksumByteSize();
746 const size_t totalSize = sizeWithoutChecksum + checksumSize;
747 buf = stream->alloc(totalSize);
748 ptr = buf;
749 int tmp = OP_rcFBSetSwapInterval;memcpy(ptr, &tmp, 4); ptr += 4;
750 memcpy(ptr, &totalSize, 4); ptr += 4;
751
752 memcpy(ptr, &interval, 4); ptr += 4;
753
754 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
755 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
756
757 }
758
rcBindTexture_enc(void * self,uint32_t colorBuffer)759 void rcBindTexture_enc(void *self , uint32_t colorBuffer)
760 {
761
762 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
763 IOStream *stream = ctx->m_stream;
764 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
765 bool useChecksum = checksumCalculator->getVersion() > 0;
766
767 unsigned char *ptr;
768 unsigned char *buf;
769 const size_t sizeWithoutChecksum = 8 + 4;
770 const size_t checksumSize = checksumCalculator->checksumByteSize();
771 const size_t totalSize = sizeWithoutChecksum + checksumSize;
772 buf = stream->alloc(totalSize);
773 ptr = buf;
774 int tmp = OP_rcBindTexture;memcpy(ptr, &tmp, 4); ptr += 4;
775 memcpy(ptr, &totalSize, 4); ptr += 4;
776
777 memcpy(ptr, &colorBuffer, 4); ptr += 4;
778
779 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
780 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
781
782 }
783
rcBindRenderbuffer_enc(void * self,uint32_t colorBuffer)784 void rcBindRenderbuffer_enc(void *self , uint32_t colorBuffer)
785 {
786
787 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
788 IOStream *stream = ctx->m_stream;
789 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
790 bool useChecksum = checksumCalculator->getVersion() > 0;
791
792 unsigned char *ptr;
793 unsigned char *buf;
794 const size_t sizeWithoutChecksum = 8 + 4;
795 const size_t checksumSize = checksumCalculator->checksumByteSize();
796 const size_t totalSize = sizeWithoutChecksum + checksumSize;
797 buf = stream->alloc(totalSize);
798 ptr = buf;
799 int tmp = OP_rcBindRenderbuffer;memcpy(ptr, &tmp, 4); ptr += 4;
800 memcpy(ptr, &totalSize, 4); ptr += 4;
801
802 memcpy(ptr, &colorBuffer, 4); ptr += 4;
803
804 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
805 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
806
807 }
808
rcColorBufferCacheFlush_enc(void * self,uint32_t colorbuffer,EGLint postCount,int forRead)809 EGLint rcColorBufferCacheFlush_enc(void *self , uint32_t colorbuffer, EGLint postCount, int forRead)
810 {
811
812 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
813 IOStream *stream = ctx->m_stream;
814 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
815 bool useChecksum = checksumCalculator->getVersion() > 0;
816
817 unsigned char *ptr;
818 unsigned char *buf;
819 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
820 const size_t checksumSize = checksumCalculator->checksumByteSize();
821 const size_t totalSize = sizeWithoutChecksum + checksumSize;
822 buf = stream->alloc(totalSize);
823 ptr = buf;
824 int tmp = OP_rcColorBufferCacheFlush;memcpy(ptr, &tmp, 4); ptr += 4;
825 memcpy(ptr, &totalSize, 4); ptr += 4;
826
827 memcpy(ptr, &colorbuffer, 4); ptr += 4;
828 memcpy(ptr, &postCount, 4); ptr += 4;
829 memcpy(ptr, &forRead, 4); ptr += 4;
830
831 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
832 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
833
834
835 EGLint retval;
836 stream->readback(&retval, 4);
837 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
838 if (useChecksum) {
839 unsigned char *checksumBufPtr = NULL;
840 std::vector<unsigned char> checksumBuf(checksumSize);
841 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
842 stream->readback(checksumBufPtr, checksumSize);
843 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
844 ALOGE("rcColorBufferCacheFlush: GL communication error, please report this issue to b.android.com.\n");
845 abort();
846 }
847 }
848 return retval;
849 }
850
rcReadColorBuffer_enc(void * self,uint32_t colorbuffer,GLint x,GLint y,GLint width,GLint height,GLenum format,GLenum type,void * pixels)851 void rcReadColorBuffer_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels)
852 {
853
854 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
855 IOStream *stream = ctx->m_stream;
856 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
857 bool useChecksum = checksumCalculator->getVersion() > 0;
858
859 const unsigned int __size_pixels = (((glUtilsPixelBitSize(format, type) * width) >> 3) * height);
860 unsigned char *ptr;
861 unsigned char *buf;
862 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
863 const size_t checksumSize = checksumCalculator->checksumByteSize();
864 const size_t totalSize = sizeWithoutChecksum + checksumSize;
865 buf = stream->alloc(totalSize);
866 ptr = buf;
867 int tmp = OP_rcReadColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
868 memcpy(ptr, &totalSize, 4); ptr += 4;
869
870 memcpy(ptr, &colorbuffer, 4); ptr += 4;
871 memcpy(ptr, &x, 4); ptr += 4;
872 memcpy(ptr, &y, 4); ptr += 4;
873 memcpy(ptr, &width, 4); ptr += 4;
874 memcpy(ptr, &height, 4); ptr += 4;
875 memcpy(ptr, &format, 4); ptr += 4;
876 memcpy(ptr, &type, 4); ptr += 4;
877 *(unsigned int *)(ptr) = __size_pixels; ptr += 4;
878
879 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
880 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
881
882 stream->readback(pixels, __size_pixels);
883 if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
884 if (useChecksum) {
885 unsigned char *checksumBufPtr = NULL;
886 std::vector<unsigned char> checksumBuf(checksumSize);
887 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
888 stream->readback(checksumBufPtr, checksumSize);
889 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
890 ALOGE("rcReadColorBuffer: GL communication error, please report this issue to b.android.com.\n");
891 abort();
892 }
893 }
894 }
895
rcUpdateColorBuffer_enc(void * self,uint32_t colorbuffer,GLint x,GLint y,GLint width,GLint height,GLenum format,GLenum type,void * pixels)896 int rcUpdateColorBuffer_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels)
897 {
898
899 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
900 IOStream *stream = ctx->m_stream;
901 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
902 bool useChecksum = checksumCalculator->getVersion() > 0;
903
904 const unsigned int __size_pixels = (((glUtilsPixelBitSize(format, type) * width) >> 3) * height);
905 unsigned char *ptr;
906 unsigned char *buf;
907 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
908 const size_t checksumSize = checksumCalculator->checksumByteSize();
909 const size_t totalSize = sizeWithoutChecksum + checksumSize;
910 buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
911 ptr = buf;
912 int tmp = OP_rcUpdateColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
913 memcpy(ptr, &totalSize, 4); ptr += 4;
914
915 memcpy(ptr, &colorbuffer, 4); ptr += 4;
916 memcpy(ptr, &x, 4); ptr += 4;
917 memcpy(ptr, &y, 4); ptr += 4;
918 memcpy(ptr, &width, 4); ptr += 4;
919 memcpy(ptr, &height, 4); ptr += 4;
920 memcpy(ptr, &format, 4); ptr += 4;
921 memcpy(ptr, &type, 4); ptr += 4;
922
923 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
924 stream->flush();
925 stream->writeFully(&__size_pixels,4);
926 if (useChecksum) checksumCalculator->addBuffer(&__size_pixels,4);
927 stream->writeFully(pixels, __size_pixels);
928 if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
929 buf = stream->alloc(checksumSize);
930 if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
931
932
933 int retval;
934 stream->readback(&retval, 4);
935 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
936 if (useChecksum) {
937 unsigned char *checksumBufPtr = NULL;
938 std::vector<unsigned char> checksumBuf(checksumSize);
939 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
940 stream->readback(checksumBufPtr, checksumSize);
941 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
942 ALOGE("rcUpdateColorBuffer: GL communication error, please report this issue to b.android.com.\n");
943 abort();
944 }
945 }
946 return retval;
947 }
948
rcOpenColorBuffer2_enc(void * self,uint32_t colorbuffer)949 int rcOpenColorBuffer2_enc(void *self , uint32_t colorbuffer)
950 {
951
952 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
953 IOStream *stream = ctx->m_stream;
954 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
955 bool useChecksum = checksumCalculator->getVersion() > 0;
956
957 unsigned char *ptr;
958 unsigned char *buf;
959 const size_t sizeWithoutChecksum = 8 + 4;
960 const size_t checksumSize = checksumCalculator->checksumByteSize();
961 const size_t totalSize = sizeWithoutChecksum + checksumSize;
962 buf = stream->alloc(totalSize);
963 ptr = buf;
964 int tmp = OP_rcOpenColorBuffer2;memcpy(ptr, &tmp, 4); ptr += 4;
965 memcpy(ptr, &totalSize, 4); ptr += 4;
966
967 memcpy(ptr, &colorbuffer, 4); ptr += 4;
968
969 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
970 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
971
972
973 int retval;
974 stream->readback(&retval, 4);
975 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
976 if (useChecksum) {
977 unsigned char *checksumBufPtr = NULL;
978 std::vector<unsigned char> checksumBuf(checksumSize);
979 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
980 stream->readback(checksumBufPtr, checksumSize);
981 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
982 ALOGE("rcOpenColorBuffer2: GL communication error, please report this issue to b.android.com.\n");
983 abort();
984 }
985 }
986 return retval;
987 }
988
rcCreateClientImage_enc(void * self,uint32_t context,EGLenum target,GLuint buffer)989 uint32_t rcCreateClientImage_enc(void *self , uint32_t context, EGLenum target, GLuint buffer)
990 {
991
992 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
993 IOStream *stream = ctx->m_stream;
994 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
995 bool useChecksum = checksumCalculator->getVersion() > 0;
996
997 unsigned char *ptr;
998 unsigned char *buf;
999 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
1000 const size_t checksumSize = checksumCalculator->checksumByteSize();
1001 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1002 buf = stream->alloc(totalSize);
1003 ptr = buf;
1004 int tmp = OP_rcCreateClientImage;memcpy(ptr, &tmp, 4); ptr += 4;
1005 memcpy(ptr, &totalSize, 4); ptr += 4;
1006
1007 memcpy(ptr, &context, 4); ptr += 4;
1008 memcpy(ptr, &target, 4); ptr += 4;
1009 memcpy(ptr, &buffer, 4); ptr += 4;
1010
1011 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1012 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1013
1014
1015 uint32_t retval;
1016 stream->readback(&retval, 4);
1017 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1018 if (useChecksum) {
1019 unsigned char *checksumBufPtr = NULL;
1020 std::vector<unsigned char> checksumBuf(checksumSize);
1021 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1022 stream->readback(checksumBufPtr, checksumSize);
1023 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1024 ALOGE("rcCreateClientImage: GL communication error, please report this issue to b.android.com.\n");
1025 abort();
1026 }
1027 }
1028 return retval;
1029 }
1030
rcDestroyClientImage_enc(void * self,uint32_t image)1031 int rcDestroyClientImage_enc(void *self , uint32_t image)
1032 {
1033
1034 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1035 IOStream *stream = ctx->m_stream;
1036 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1037 bool useChecksum = checksumCalculator->getVersion() > 0;
1038
1039 unsigned char *ptr;
1040 unsigned char *buf;
1041 const size_t sizeWithoutChecksum = 8 + 4;
1042 const size_t checksumSize = checksumCalculator->checksumByteSize();
1043 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1044 buf = stream->alloc(totalSize);
1045 ptr = buf;
1046 int tmp = OP_rcDestroyClientImage;memcpy(ptr, &tmp, 4); ptr += 4;
1047 memcpy(ptr, &totalSize, 4); ptr += 4;
1048
1049 memcpy(ptr, &image, 4); ptr += 4;
1050
1051 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1052 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1053
1054
1055 int retval;
1056 stream->readback(&retval, 4);
1057 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1058 if (useChecksum) {
1059 unsigned char *checksumBufPtr = NULL;
1060 std::vector<unsigned char> checksumBuf(checksumSize);
1061 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1062 stream->readback(checksumBufPtr, checksumSize);
1063 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1064 ALOGE("rcDestroyClientImage: GL communication error, please report this issue to b.android.com.\n");
1065 abort();
1066 }
1067 }
1068 return retval;
1069 }
1070
rcSelectChecksumHelper_enc(void * self,uint32_t newProtocol,uint32_t reserved)1071 void rcSelectChecksumHelper_enc(void *self , uint32_t newProtocol, uint32_t reserved)
1072 {
1073
1074 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1075 IOStream *stream = ctx->m_stream;
1076 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1077 bool useChecksum = checksumCalculator->getVersion() > 0;
1078
1079 unsigned char *ptr;
1080 unsigned char *buf;
1081 const size_t sizeWithoutChecksum = 8 + 4 + 4;
1082 const size_t checksumSize = checksumCalculator->checksumByteSize();
1083 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1084 buf = stream->alloc(totalSize);
1085 ptr = buf;
1086 int tmp = OP_rcSelectChecksumHelper;memcpy(ptr, &tmp, 4); ptr += 4;
1087 memcpy(ptr, &totalSize, 4); ptr += 4;
1088
1089 memcpy(ptr, &newProtocol, 4); ptr += 4;
1090 memcpy(ptr, &reserved, 4); ptr += 4;
1091
1092 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1093 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1094
1095 }
1096
rcCreateSyncKHR_enc(void * self,EGLenum type,EGLint * attribs,uint32_t num_attribs,int destroy_when_signaled,uint64_t * glsync_out,uint64_t * syncthread_out)1097 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)
1098 {
1099
1100 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1101 IOStream *stream = ctx->m_stream;
1102 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1103 bool useChecksum = checksumCalculator->getVersion() > 0;
1104
1105 const unsigned int __size_attribs = num_attribs;
1106 const unsigned int __size_glsync_out = sizeof(uint64_t);
1107 const unsigned int __size_syncthread_out = sizeof(uint64_t);
1108 unsigned char *ptr;
1109 unsigned char *buf;
1110 const size_t sizeWithoutChecksum = 8 + 4 + __size_attribs + 4 + 4 + __size_glsync_out + __size_syncthread_out + 3*4;
1111 const size_t checksumSize = checksumCalculator->checksumByteSize();
1112 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1113 buf = stream->alloc(totalSize);
1114 ptr = buf;
1115 int tmp = OP_rcCreateSyncKHR;memcpy(ptr, &tmp, 4); ptr += 4;
1116 memcpy(ptr, &totalSize, 4); ptr += 4;
1117
1118 memcpy(ptr, &type, 4); ptr += 4;
1119 *(unsigned int *)(ptr) = __size_attribs; ptr += 4;
1120 memcpy(ptr, attribs, __size_attribs);ptr += __size_attribs;
1121 memcpy(ptr, &num_attribs, 4); ptr += 4;
1122 memcpy(ptr, &destroy_when_signaled, 4); ptr += 4;
1123 *(unsigned int *)(ptr) = __size_glsync_out; ptr += 4;
1124 *(unsigned int *)(ptr) = __size_syncthread_out; ptr += 4;
1125
1126 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1127 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1128
1129 stream->readback(glsync_out, __size_glsync_out);
1130 if (useChecksum) checksumCalculator->addBuffer(glsync_out, __size_glsync_out);
1131 stream->readback(syncthread_out, __size_syncthread_out);
1132 if (useChecksum) checksumCalculator->addBuffer(syncthread_out, __size_syncthread_out);
1133 if (useChecksum) {
1134 unsigned char *checksumBufPtr = NULL;
1135 std::vector<unsigned char> checksumBuf(checksumSize);
1136 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1137 stream->readback(checksumBufPtr, checksumSize);
1138 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1139 ALOGE("rcCreateSyncKHR: GL communication error, please report this issue to b.android.com.\n");
1140 abort();
1141 }
1142 }
1143 }
1144
rcClientWaitSyncKHR_enc(void * self,uint64_t sync,EGLint flags,uint64_t timeout)1145 EGLint rcClientWaitSyncKHR_enc(void *self , uint64_t sync, EGLint flags, uint64_t timeout)
1146 {
1147
1148 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1149 IOStream *stream = ctx->m_stream;
1150 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1151 bool useChecksum = checksumCalculator->getVersion() > 0;
1152
1153 unsigned char *ptr;
1154 unsigned char *buf;
1155 const size_t sizeWithoutChecksum = 8 + 8 + 4 + 8;
1156 const size_t checksumSize = checksumCalculator->checksumByteSize();
1157 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1158 buf = stream->alloc(totalSize);
1159 ptr = buf;
1160 int tmp = OP_rcClientWaitSyncKHR;memcpy(ptr, &tmp, 4); ptr += 4;
1161 memcpy(ptr, &totalSize, 4); ptr += 4;
1162
1163 memcpy(ptr, &sync, 8); ptr += 8;
1164 memcpy(ptr, &flags, 4); ptr += 4;
1165 memcpy(ptr, &timeout, 8); ptr += 8;
1166
1167 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1168 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1169
1170
1171 EGLint retval;
1172 stream->readback(&retval, 4);
1173 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1174 if (useChecksum) {
1175 unsigned char *checksumBufPtr = NULL;
1176 std::vector<unsigned char> checksumBuf(checksumSize);
1177 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1178 stream->readback(checksumBufPtr, checksumSize);
1179 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1180 ALOGE("rcClientWaitSyncKHR: GL communication error, please report this issue to b.android.com.\n");
1181 abort();
1182 }
1183 }
1184 return retval;
1185 }
1186
rcFlushWindowColorBufferAsync_enc(void * self,uint32_t windowSurface)1187 void rcFlushWindowColorBufferAsync_enc(void *self , uint32_t windowSurface)
1188 {
1189
1190 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1191 IOStream *stream = ctx->m_stream;
1192 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1193 bool useChecksum = checksumCalculator->getVersion() > 0;
1194
1195 unsigned char *ptr;
1196 unsigned char *buf;
1197 const size_t sizeWithoutChecksum = 8 + 4;
1198 const size_t checksumSize = checksumCalculator->checksumByteSize();
1199 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1200 buf = stream->alloc(totalSize);
1201 ptr = buf;
1202 int tmp = OP_rcFlushWindowColorBufferAsync;memcpy(ptr, &tmp, 4); ptr += 4;
1203 memcpy(ptr, &totalSize, 4); ptr += 4;
1204
1205 memcpy(ptr, &windowSurface, 4); ptr += 4;
1206
1207 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1208 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1209
1210 }
1211
rcDestroySyncKHR_enc(void * self,uint64_t sync)1212 int rcDestroySyncKHR_enc(void *self , uint64_t sync)
1213 {
1214
1215 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1216 IOStream *stream = ctx->m_stream;
1217 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1218 bool useChecksum = checksumCalculator->getVersion() > 0;
1219
1220 unsigned char *ptr;
1221 unsigned char *buf;
1222 const size_t sizeWithoutChecksum = 8 + 8;
1223 const size_t checksumSize = checksumCalculator->checksumByteSize();
1224 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1225 buf = stream->alloc(totalSize);
1226 ptr = buf;
1227 int tmp = OP_rcDestroySyncKHR;memcpy(ptr, &tmp, 4); ptr += 4;
1228 memcpy(ptr, &totalSize, 4); ptr += 4;
1229
1230 memcpy(ptr, &sync, 8); ptr += 8;
1231
1232 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1233 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1234
1235
1236 int retval;
1237 stream->readback(&retval, 4);
1238 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1239 if (useChecksum) {
1240 unsigned char *checksumBufPtr = NULL;
1241 std::vector<unsigned char> checksumBuf(checksumSize);
1242 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1243 stream->readback(checksumBufPtr, checksumSize);
1244 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1245 ALOGE("rcDestroySyncKHR: GL communication error, please report this issue to b.android.com.\n");
1246 abort();
1247 }
1248 }
1249 return retval;
1250 }
1251
rcSetPuid_enc(void * self,uint64_t puid)1252 void rcSetPuid_enc(void *self , uint64_t puid)
1253 {
1254
1255 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1256 IOStream *stream = ctx->m_stream;
1257 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1258 bool useChecksum = checksumCalculator->getVersion() > 0;
1259
1260 unsigned char *ptr;
1261 unsigned char *buf;
1262 const size_t sizeWithoutChecksum = 8 + 8;
1263 const size_t checksumSize = checksumCalculator->checksumByteSize();
1264 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1265 buf = stream->alloc(totalSize);
1266 ptr = buf;
1267 int tmp = OP_rcSetPuid;memcpy(ptr, &tmp, 4); ptr += 4;
1268 memcpy(ptr, &totalSize, 4); ptr += 4;
1269
1270 memcpy(ptr, &puid, 8); ptr += 8;
1271
1272 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1273 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1274
1275 }
1276
1277 } // namespace
1278
renderControl_encoder_context_t(IOStream * stream,ChecksumCalculator * checksumCalculator)1279 renderControl_encoder_context_t::renderControl_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator)
1280 {
1281 m_stream = stream;
1282 m_checksumCalculator = checksumCalculator;
1283
1284 this->rcGetRendererVersion = &rcGetRendererVersion_enc;
1285 this->rcGetEGLVersion = &rcGetEGLVersion_enc;
1286 this->rcQueryEGLString = &rcQueryEGLString_enc;
1287 this->rcGetGLString = &rcGetGLString_enc;
1288 this->rcGetNumConfigs = &rcGetNumConfigs_enc;
1289 this->rcGetConfigs = &rcGetConfigs_enc;
1290 this->rcChooseConfig = &rcChooseConfig_enc;
1291 this->rcGetFBParam = &rcGetFBParam_enc;
1292 this->rcCreateContext = &rcCreateContext_enc;
1293 this->rcDestroyContext = &rcDestroyContext_enc;
1294 this->rcCreateWindowSurface = &rcCreateWindowSurface_enc;
1295 this->rcDestroyWindowSurface = &rcDestroyWindowSurface_enc;
1296 this->rcCreateColorBuffer = &rcCreateColorBuffer_enc;
1297 this->rcOpenColorBuffer = &rcOpenColorBuffer_enc;
1298 this->rcCloseColorBuffer = &rcCloseColorBuffer_enc;
1299 this->rcSetWindowColorBuffer = &rcSetWindowColorBuffer_enc;
1300 this->rcFlushWindowColorBuffer = &rcFlushWindowColorBuffer_enc;
1301 this->rcMakeCurrent = &rcMakeCurrent_enc;
1302 this->rcFBPost = &rcFBPost_enc;
1303 this->rcFBSetSwapInterval = &rcFBSetSwapInterval_enc;
1304 this->rcBindTexture = &rcBindTexture_enc;
1305 this->rcBindRenderbuffer = &rcBindRenderbuffer_enc;
1306 this->rcColorBufferCacheFlush = &rcColorBufferCacheFlush_enc;
1307 this->rcReadColorBuffer = &rcReadColorBuffer_enc;
1308 this->rcUpdateColorBuffer = &rcUpdateColorBuffer_enc;
1309 this->rcOpenColorBuffer2 = &rcOpenColorBuffer2_enc;
1310 this->rcCreateClientImage = &rcCreateClientImage_enc;
1311 this->rcDestroyClientImage = &rcDestroyClientImage_enc;
1312 this->rcSelectChecksumHelper = &rcSelectChecksumHelper_enc;
1313 this->rcCreateSyncKHR = &rcCreateSyncKHR_enc;
1314 this->rcClientWaitSyncKHR = &rcClientWaitSyncKHR_enc;
1315 this->rcFlushWindowColorBufferAsync = &rcFlushWindowColorBufferAsync_enc;
1316 this->rcDestroySyncKHR = &rcDestroySyncKHR_enc;
1317 this->rcSetPuid = &rcSetPuid_enc;
1318 }
1319
1320