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