src/type3_AndroidCloud/anbox-master/android/opengl/system/renderControl_enc/renderControl_enc.cpp

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