system/renderControl_enc/renderControl_enc.cpp

   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
  16 void enc_unsupported()
  17 {
  18         ALOGE("Function is unsupported\n");
  19 }
  20
  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
  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
 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
 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
 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
 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
 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
 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, &param, 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
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
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
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
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
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
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
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
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