1 // Generated Code - DO NOT EDIT !!
2 // generated by 'emugen'
7 #include "renderControl_opcodes.h"
9 #include "renderControl_enc.h"
16 void enc_unsupported()
18 ALOGE("Function is unsupported\n");
21 GLint rcGetRendererVersion_enc(void *self )
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;
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);
36 int tmp = OP_rcGetRendererVersion;memcpy(ptr, &tmp, 4); ptr += 4;
37 memcpy(ptr, &totalSize, 4); ptr += 4;
40 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
41 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
45 stream->readback(&retval, 4);
46 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
60 EGLint rcGetEGLVersion_enc(void *self , EGLint* major, EGLint* minor)
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;
68 const unsigned int __size_major = sizeof(EGLint);
69 const unsigned int __size_minor = sizeof(EGLint);
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);
77 int tmp = OP_rcGetEGLVersion;memcpy(ptr, &tmp, 4); ptr += 4;
78 memcpy(ptr, &totalSize, 4); ptr += 4;
80 *(unsigned int *)(ptr) = __size_major; ptr += 4;
81 *(unsigned int *)(ptr) = __size_minor; ptr += 4;
83 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
84 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
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);
92 stream->readback(&retval, 4);
93 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
107 EGLint rcQueryEGLString_enc(void *self , EGLenum name, void* buffer, EGLint bufferSize)
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;
115 const unsigned int __size_buffer = bufferSize;
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);
123 int tmp = OP_rcQueryEGLString;memcpy(ptr, &tmp, 4); ptr += 4;
124 memcpy(ptr, &totalSize, 4); ptr += 4;
126 memcpy(ptr, &name, 4); ptr += 4;
127 *(unsigned int *)(ptr) = __size_buffer; ptr += 4;
128 memcpy(ptr, &bufferSize, 4); ptr += 4;
130 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
131 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
133 stream->readback(buffer, __size_buffer);
134 if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer);
137 stream->readback(&retval, 4);
138 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
152 EGLint rcGetGLString_enc(void *self , EGLenum name, void* buffer, EGLint bufferSize)
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;
160 const unsigned int __size_buffer = bufferSize;
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);
168 int tmp = OP_rcGetGLString;memcpy(ptr, &tmp, 4); ptr += 4;
169 memcpy(ptr, &totalSize, 4); ptr += 4;
171 memcpy(ptr, &name, 4); ptr += 4;
172 *(unsigned int *)(ptr) = __size_buffer; ptr += 4;
173 memcpy(ptr, &bufferSize, 4); ptr += 4;
175 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
176 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
178 stream->readback(buffer, __size_buffer);
179 if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer);
182 stream->readback(&retval, 4);
183 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
197 EGLint rcGetNumConfigs_enc(void *self , uint32_t* numAttribs)
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;
205 const unsigned int __size_numAttribs = sizeof(uint32_t);
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);
213 int tmp = OP_rcGetNumConfigs;memcpy(ptr, &tmp, 4); ptr += 4;
214 memcpy(ptr, &totalSize, 4); ptr += 4;
216 *(unsigned int *)(ptr) = __size_numAttribs; ptr += 4;
218 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
219 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
221 stream->readback(numAttribs, __size_numAttribs);
222 if (useChecksum) checksumCalculator->addBuffer(numAttribs, __size_numAttribs);
225 stream->readback(&retval, 4);
226 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
240 EGLint rcGetConfigs_enc(void *self , uint32_t bufSize, GLuint* buffer)
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;
248 const unsigned int __size_buffer = bufSize;
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);
256 int tmp = OP_rcGetConfigs;memcpy(ptr, &tmp, 4); ptr += 4;
257 memcpy(ptr, &totalSize, 4); ptr += 4;
259 memcpy(ptr, &bufSize, 4); ptr += 4;
260 *(unsigned int *)(ptr) = __size_buffer; ptr += 4;
262 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
263 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
265 stream->readback(buffer, __size_buffer);
266 if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer);
269 stream->readback(&retval, 4);
270 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
284 EGLint rcChooseConfig_enc(void *self , EGLint* attribs, uint32_t attribs_size, uint32_t* configs, uint32_t configs_size)
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;
292 const unsigned int __size_attribs = attribs_size;
293 const unsigned int __size_configs = ((configs != NULL) ? configs_size*sizeof(uint32_t) : 0);
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);
301 int tmp = OP_rcChooseConfig;memcpy(ptr, &tmp, 4); ptr += 4;
302 memcpy(ptr, &totalSize, 4); ptr += 4;
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;
310 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
311 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
313 if (configs != NULL) {
314 stream->readback(configs, __size_configs);
315 if (useChecksum) checksumCalculator->addBuffer(configs, __size_configs);
319 stream->readback(&retval, 4);
320 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
334 EGLint rcGetFBParam_enc(void *self , EGLint param)
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;
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);
349 int tmp = OP_rcGetFBParam;memcpy(ptr, &tmp, 4); ptr += 4;
350 memcpy(ptr, &totalSize, 4); ptr += 4;
352 memcpy(ptr, ¶m, 4); ptr += 4;
354 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
355 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
359 stream->readback(&retval, 4);
360 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
374 uint32_t rcCreateContext_enc(void *self , uint32_t config, uint32_t share, uint32_t glVersion)
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;
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);
389 int tmp = OP_rcCreateContext;memcpy(ptr, &tmp, 4); ptr += 4;
390 memcpy(ptr, &totalSize, 4); ptr += 4;
392 memcpy(ptr, &config, 4); ptr += 4;
393 memcpy(ptr, &share, 4); ptr += 4;
394 memcpy(ptr, &glVersion, 4); ptr += 4;
396 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
397 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
401 stream->readback(&retval, 4);
402 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
416 void rcDestroyContext_enc(void *self , uint32_t context)
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;
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);
431 int tmp = OP_rcDestroyContext;memcpy(ptr, &tmp, 4); ptr += 4;
432 memcpy(ptr, &totalSize, 4); ptr += 4;
434 memcpy(ptr, &context, 4); ptr += 4;
436 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
437 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
441 uint32_t rcCreateWindowSurface_enc(void *self , uint32_t config, uint32_t width, uint32_t height)
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;
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);
456 int tmp = OP_rcCreateWindowSurface;memcpy(ptr, &tmp, 4); ptr += 4;
457 memcpy(ptr, &totalSize, 4); ptr += 4;
459 memcpy(ptr, &config, 4); ptr += 4;
460 memcpy(ptr, &width, 4); ptr += 4;
461 memcpy(ptr, &height, 4); ptr += 4;
463 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
464 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
468 stream->readback(&retval, 4);
469 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
483 void rcDestroyWindowSurface_enc(void *self , uint32_t windowSurface)
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;
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);
498 int tmp = OP_rcDestroyWindowSurface;memcpy(ptr, &tmp, 4); ptr += 4;
499 memcpy(ptr, &totalSize, 4); ptr += 4;
501 memcpy(ptr, &windowSurface, 4); ptr += 4;
503 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
504 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
508 uint32_t rcCreateColorBuffer_enc(void *self , uint32_t width, uint32_t height, GLenum internalFormat)
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;
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);
523 int tmp = OP_rcCreateColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
524 memcpy(ptr, &totalSize, 4); ptr += 4;
526 memcpy(ptr, &width, 4); ptr += 4;
527 memcpy(ptr, &height, 4); ptr += 4;
528 memcpy(ptr, &internalFormat, 4); ptr += 4;
530 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
531 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
535 stream->readback(&retval, 4);
536 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
550 void rcOpenColorBuffer_enc(void *self , uint32_t colorbuffer)
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;
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);
565 int tmp = OP_rcOpenColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
566 memcpy(ptr, &totalSize, 4); ptr += 4;
568 memcpy(ptr, &colorbuffer, 4); ptr += 4;
570 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
571 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
575 void rcCloseColorBuffer_enc(void *self , uint32_t colorbuffer)
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;
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);
590 int tmp = OP_rcCloseColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
591 memcpy(ptr, &totalSize, 4); ptr += 4;
593 memcpy(ptr, &colorbuffer, 4); ptr += 4;
595 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
596 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
601 void rcSetWindowColorBuffer_enc(void *self , uint32_t windowSurface, uint32_t colorBuffer)
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;
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);
616 int tmp = OP_rcSetWindowColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
617 memcpy(ptr, &totalSize, 4); ptr += 4;
619 memcpy(ptr, &windowSurface, 4); ptr += 4;
620 memcpy(ptr, &colorBuffer, 4); ptr += 4;
622 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
623 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
627 int rcFlushWindowColorBuffer_enc(void *self , uint32_t windowSurface)
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;
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);
642 int tmp = OP_rcFlushWindowColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
643 memcpy(ptr, &totalSize, 4); ptr += 4;
645 memcpy(ptr, &windowSurface, 4); ptr += 4;
647 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
648 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
652 stream->readback(&retval, 4);
653 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
667 EGLint rcMakeCurrent_enc(void *self , uint32_t context, uint32_t drawSurf, uint32_t readSurf)
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;
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);
682 int tmp = OP_rcMakeCurrent;memcpy(ptr, &tmp, 4); ptr += 4;
683 memcpy(ptr, &totalSize, 4); ptr += 4;
685 memcpy(ptr, &context, 4); ptr += 4;
686 memcpy(ptr, &drawSurf, 4); ptr += 4;
687 memcpy(ptr, &readSurf, 4); ptr += 4;
689 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
690 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
694 stream->readback(&retval, 4);
695 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
709 void rcFBPost_enc(void *self , uint32_t colorBuffer)
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;
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);
724 int tmp = OP_rcFBPost;memcpy(ptr, &tmp, 4); ptr += 4;
725 memcpy(ptr, &totalSize, 4); ptr += 4;
727 memcpy(ptr, &colorBuffer, 4); ptr += 4;
729 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
730 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
734 void rcFBSetSwapInterval_enc(void *self , EGLint interval)
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;
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);
749 int tmp = OP_rcFBSetSwapInterval;memcpy(ptr, &tmp, 4); ptr += 4;
750 memcpy(ptr, &totalSize, 4); ptr += 4;
752 memcpy(ptr, &interval, 4); ptr += 4;
754 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
755 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
759 void rcBindTexture_enc(void *self , uint32_t colorBuffer)
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;
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);
774 int tmp = OP_rcBindTexture;memcpy(ptr, &tmp, 4); ptr += 4;
775 memcpy(ptr, &totalSize, 4); ptr += 4;
777 memcpy(ptr, &colorBuffer, 4); ptr += 4;
779 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
780 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
784 void rcBindRenderbuffer_enc(void *self , uint32_t colorBuffer)
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;
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);
799 int tmp = OP_rcBindRenderbuffer;memcpy(ptr, &tmp, 4); ptr += 4;
800 memcpy(ptr, &totalSize, 4); ptr += 4;
802 memcpy(ptr, &colorBuffer, 4); ptr += 4;
804 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
805 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
809 EGLint rcColorBufferCacheFlush_enc(void *self , uint32_t colorbuffer, EGLint postCount, int forRead)
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;
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);
824 int tmp = OP_rcColorBufferCacheFlush;memcpy(ptr, &tmp, 4); ptr += 4;
825 memcpy(ptr, &totalSize, 4); ptr += 4;
827 memcpy(ptr, &colorbuffer, 4); ptr += 4;
828 memcpy(ptr, &postCount, 4); ptr += 4;
829 memcpy(ptr, &forRead, 4); ptr += 4;
831 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
832 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
836 stream->readback(&retval, 4);
837 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
851 void rcReadColorBuffer_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels)
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;
859 const unsigned int __size_pixels = (((glUtilsPixelBitSize(format, type) * width) >> 3) * height);
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);
867 int tmp = OP_rcReadColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
868 memcpy(ptr, &totalSize, 4); ptr += 4;
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;
879 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
880 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
882 stream->readback(pixels, __size_pixels);
883 if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
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");
896 int rcUpdateColorBuffer_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels)
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;
904 const unsigned int __size_pixels = (((glUtilsPixelBitSize(format, type) * width) >> 3) * height);
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);
912 int tmp = OP_rcUpdateColorBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
913 memcpy(ptr, &totalSize, 4); ptr += 4;
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;
923 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
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);
934 stream->readback(&retval, 4);
935 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
949 int rcOpenColorBuffer2_enc(void *self , uint32_t colorbuffer)
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;
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);
964 int tmp = OP_rcOpenColorBuffer2;memcpy(ptr, &tmp, 4); ptr += 4;
965 memcpy(ptr, &totalSize, 4); ptr += 4;
967 memcpy(ptr, &colorbuffer, 4); ptr += 4;
969 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
970 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
974 stream->readback(&retval, 4);
975 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
989 uint32_t rcCreateClientImage_enc(void *self , uint32_t context, EGLenum target, GLuint buffer)
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;
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);
1004 int tmp = OP_rcCreateClientImage;memcpy(ptr, &tmp, 4); ptr += 4;
1005 memcpy(ptr, &totalSize, 4); ptr += 4;
1007 memcpy(ptr, &context, 4); ptr += 4;
1008 memcpy(ptr, &target, 4); ptr += 4;
1009 memcpy(ptr, &buffer, 4); ptr += 4;
1011 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1012 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1016 stream->readback(&retval, 4);
1017 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
1031 int rcDestroyClientImage_enc(void *self , uint32_t image)
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;
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);
1046 int tmp = OP_rcDestroyClientImage;memcpy(ptr, &tmp, 4); ptr += 4;
1047 memcpy(ptr, &totalSize, 4); ptr += 4;
1049 memcpy(ptr, &image, 4); ptr += 4;
1051 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1052 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1056 stream->readback(&retval, 4);
1057 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
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");
1071 void rcSelectChecksumHelper_enc(void *self , uint32_t newProtocol, uint32_t reserved)
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;
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);
1086 int tmp = OP_rcSelectChecksumHelper;memcpy(ptr, &tmp, 4); ptr += 4;
1087 memcpy(ptr, &totalSize, 4); ptr += 4;
1089 memcpy(ptr, &newProtocol, 4); ptr += 4;
1090 memcpy(ptr, &reserved, 4); ptr += 4;
1092 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1093 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1097 uint32_t rcCreateColorBufferPuid_enc(void *self , uint32_t width, uint32_t height, GLenum internalFormat, uint64_t puid)
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;
1107 const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 8;
1108 const size_t checksumSize = checksumCalculator->checksumByteSize();
1109 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1110 buf = stream->alloc(totalSize);
1112 int tmp = OP_rcCreateColorBufferPuid;memcpy(ptr, &tmp, 4); ptr += 4;
1113 memcpy(ptr, &totalSize, 4); ptr += 4;
1115 memcpy(ptr, &width, 4); ptr += 4;
1116 memcpy(ptr, &height, 4); ptr += 4;
1117 memcpy(ptr, &internalFormat, 4); ptr += 4;
1118 memcpy(ptr, &puid, 8); ptr += 8;
1120 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1121 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1125 stream->readback(&retval, 4);
1126 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1128 unsigned char *checksumBufPtr = NULL;
1129 std::vector<unsigned char> checksumBuf(checksumSize);
1130 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1131 stream->readback(checksumBufPtr, checksumSize);
1132 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1133 ALOGE("rcCreateColorBufferPuid: GL communication error, please report this issue to b.android.com.\n");
1140 int rcOpenColorBuffer2Puid_enc(void *self , uint32_t colorbuffer, uint64_t puid)
1143 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1144 IOStream *stream = ctx->m_stream;
1145 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1146 bool useChecksum = checksumCalculator->getVersion() > 0;
1150 const size_t sizeWithoutChecksum = 8 + 4 + 8;
1151 const size_t checksumSize = checksumCalculator->checksumByteSize();
1152 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1153 buf = stream->alloc(totalSize);
1155 int tmp = OP_rcOpenColorBuffer2Puid;memcpy(ptr, &tmp, 4); ptr += 4;
1156 memcpy(ptr, &totalSize, 4); ptr += 4;
1158 memcpy(ptr, &colorbuffer, 4); ptr += 4;
1159 memcpy(ptr, &puid, 8); ptr += 8;
1161 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1162 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1166 stream->readback(&retval, 4);
1167 if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1169 unsigned char *checksumBufPtr = NULL;
1170 std::vector<unsigned char> checksumBuf(checksumSize);
1171 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1172 stream->readback(checksumBufPtr, checksumSize);
1173 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1174 ALOGE("rcOpenColorBuffer2Puid: GL communication error, please report this issue to b.android.com.\n");
1181 void rcCloseColorBufferPuid_enc(void *self , uint32_t colorbuffer, uint64_t puid)
1184 renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
1185 IOStream *stream = ctx->m_stream;
1186 ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1187 bool useChecksum = checksumCalculator->getVersion() > 0;
1191 const size_t sizeWithoutChecksum = 8 + 4 + 8;
1192 const size_t checksumSize = checksumCalculator->checksumByteSize();
1193 const size_t totalSize = sizeWithoutChecksum + checksumSize;
1194 buf = stream->alloc(totalSize);
1196 int tmp = OP_rcCloseColorBufferPuid;memcpy(ptr, &tmp, 4); ptr += 4;
1197 memcpy(ptr, &totalSize, 4); ptr += 4;
1199 memcpy(ptr, &colorbuffer, 4); ptr += 4;
1200 memcpy(ptr, &puid, 8); ptr += 8;
1202 if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1203 if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1209 renderControl_encoder_context_t::renderControl_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator)
1212 m_checksumCalculator = checksumCalculator;
1214 this->rcGetRendererVersion = &rcGetRendererVersion_enc;
1215 this->rcGetEGLVersion = &rcGetEGLVersion_enc;
1216 this->rcQueryEGLString = &rcQueryEGLString_enc;
1217 this->rcGetGLString = &rcGetGLString_enc;
1218 this->rcGetNumConfigs = &rcGetNumConfigs_enc;
1219 this->rcGetConfigs = &rcGetConfigs_enc;
1220 this->rcChooseConfig = &rcChooseConfig_enc;
1221 this->rcGetFBParam = &rcGetFBParam_enc;
1222 this->rcCreateContext = &rcCreateContext_enc;
1223 this->rcDestroyContext = &rcDestroyContext_enc;
1224 this->rcCreateWindowSurface = &rcCreateWindowSurface_enc;
1225 this->rcDestroyWindowSurface = &rcDestroyWindowSurface_enc;
1226 this->rcCreateColorBuffer = &rcCreateColorBuffer_enc;
1227 this->rcOpenColorBuffer = &rcOpenColorBuffer_enc;
1228 this->rcCloseColorBuffer = &rcCloseColorBuffer_enc;
1229 this->rcSetWindowColorBuffer = &rcSetWindowColorBuffer_enc;
1230 this->rcFlushWindowColorBuffer = &rcFlushWindowColorBuffer_enc;
1231 this->rcMakeCurrent = &rcMakeCurrent_enc;
1232 this->rcFBPost = &rcFBPost_enc;
1233 this->rcFBSetSwapInterval = &rcFBSetSwapInterval_enc;
1234 this->rcBindTexture = &rcBindTexture_enc;
1235 this->rcBindRenderbuffer = &rcBindRenderbuffer_enc;
1236 this->rcColorBufferCacheFlush = &rcColorBufferCacheFlush_enc;
1237 this->rcReadColorBuffer = &rcReadColorBuffer_enc;
1238 this->rcUpdateColorBuffer = &rcUpdateColorBuffer_enc;
1239 this->rcOpenColorBuffer2 = &rcOpenColorBuffer2_enc;
1240 this->rcCreateClientImage = &rcCreateClientImage_enc;
1241 this->rcDestroyClientImage = &rcDestroyClientImage_enc;
1242 this->rcSelectChecksumHelper = &rcSelectChecksumHelper_enc;
1243 this->rcCreateColorBufferPuid = &rcCreateColorBufferPuid_enc;
1244 this->rcOpenColorBuffer2Puid = &rcOpenColorBuffer2Puid_enc;
1245 this->rcCloseColorBufferPuid = &rcCloseColorBufferPuid_enc;