system/GLESv2_enc/gl2_enc.cpp

   1 // Generated Code - DO NOT EDIT !!
   2 // generated by 'emugen'
   3
   4
   5 #include <string.h>
   6 #include "gl2_opcodes.h"
   7
   8 #include "gl2_enc.h"
   9
  10
  11 #include <stdio.h>
  12
  13 namespace {
  14
  15 void enc_unsupported()
  16 {
  17         ALOGE("Function is unsupported\n");
  18 }
  19
  20 void glActiveTexture_enc(void *self , GLenum texture)
  21 {
  22
  23         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
  24         IOStream *stream = ctx->m_stream;
  25         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
  26         bool useChecksum = checksumCalculator->getVersion() > 0;
  27
  28          unsigned char *ptr;
  29          unsigned char *buf;
  30          const size_t sizeWithoutChecksum = 8 + 4;
  31          const size_t checksumSize = checksumCalculator->checksumByteSize();
  32          const size_t totalSize = sizeWithoutChecksum + checksumSize;
  33         buf = stream->alloc(totalSize);
  34         ptr = buf;
  35         int tmp = OP_glActiveTexture;memcpy(ptr, &tmp, 4); ptr += 4;
  36         memcpy(ptr, &totalSize, 4);  ptr += 4;
  37
  38                 memcpy(ptr, &texture, 4); ptr += 4;
  39
  40         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
  41         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
  42
  43 }
  44
  45 void glAttachShader_enc(void *self , GLuint program, GLuint shader)
  46 {
  47
  48         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
  49         IOStream *stream = ctx->m_stream;
  50         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
  51         bool useChecksum = checksumCalculator->getVersion() > 0;
  52
  53          unsigned char *ptr;
  54          unsigned char *buf;
  55          const size_t sizeWithoutChecksum = 8 + 4 + 4;
  56          const size_t checksumSize = checksumCalculator->checksumByteSize();
  57          const size_t totalSize = sizeWithoutChecksum + checksumSize;
  58         buf = stream->alloc(totalSize);
  59         ptr = buf;
  60         int tmp = OP_glAttachShader;memcpy(ptr, &tmp, 4); ptr += 4;
  61         memcpy(ptr, &totalSize, 4);  ptr += 4;
  62
  63                 memcpy(ptr, &program, 4); ptr += 4;
  64                 memcpy(ptr, &shader, 4); ptr += 4;
  65
  66         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
  67         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
  68
  69 }
  70
  71 void glBindAttribLocation_enc(void *self , GLuint program, GLuint index, const GLchar* name)
  72 {
  73
  74         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
  75         IOStream *stream = ctx->m_stream;
  76         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
  77         bool useChecksum = checksumCalculator->getVersion() > 0;
  78
  79         const unsigned int __size_name =  (strlen(name) + 1);
  80          unsigned char *ptr;
  81          unsigned char *buf;
  82          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_name + 1*4;
  83          const size_t checksumSize = checksumCalculator->checksumByteSize();
  84          const size_t totalSize = sizeWithoutChecksum + checksumSize;
  85         buf = stream->alloc(totalSize);
  86         ptr = buf;
  87         int tmp = OP_glBindAttribLocation;memcpy(ptr, &tmp, 4); ptr += 4;
  88         memcpy(ptr, &totalSize, 4);  ptr += 4;
  89
  90                 memcpy(ptr, &program, 4); ptr += 4;
  91                 memcpy(ptr, &index, 4); ptr += 4;
  92         *(unsigned int *)(ptr) = __size_name; ptr += 4;
  93         memcpy(ptr, name, __size_name);ptr += __size_name;
  94
  95         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
  96         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
  97
  98 }
  99
 100 void glBindBuffer_enc(void *self , GLenum target, GLuint buffer)
 101 {
 102
 103         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 104         IOStream *stream = ctx->m_stream;
 105         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 106         bool useChecksum = checksumCalculator->getVersion() > 0;
 107
 108          unsigned char *ptr;
 109          unsigned char *buf;
 110          const size_t sizeWithoutChecksum = 8 + 4 + 4;
 111          const size_t checksumSize = checksumCalculator->checksumByteSize();
 112          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 113         buf = stream->alloc(totalSize);
 114         ptr = buf;
 115         int tmp = OP_glBindBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
 116         memcpy(ptr, &totalSize, 4);  ptr += 4;
 117
 118                 memcpy(ptr, &target, 4); ptr += 4;
 119                 memcpy(ptr, &buffer, 4); ptr += 4;
 120
 121         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 122         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 123
 124 }
 125
 126 void glBindFramebuffer_enc(void *self , GLenum target, GLuint framebuffer)
 127 {
 128
 129         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 130         IOStream *stream = ctx->m_stream;
 131         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 132         bool useChecksum = checksumCalculator->getVersion() > 0;
 133
 134          unsigned char *ptr;
 135          unsigned char *buf;
 136          const size_t sizeWithoutChecksum = 8 + 4 + 4;
 137          const size_t checksumSize = checksumCalculator->checksumByteSize();
 138          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 139         buf = stream->alloc(totalSize);
 140         ptr = buf;
 141         int tmp = OP_glBindFramebuffer;memcpy(ptr, &tmp, 4); ptr += 4;
 142         memcpy(ptr, &totalSize, 4);  ptr += 4;
 143
 144                 memcpy(ptr, &target, 4); ptr += 4;
 145                 memcpy(ptr, &framebuffer, 4); ptr += 4;
 146
 147         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 148         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 149
 150 }
 151
 152 void glBindRenderbuffer_enc(void *self , GLenum target, GLuint renderbuffer)
 153 {
 154
 155         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 156         IOStream *stream = ctx->m_stream;
 157         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 158         bool useChecksum = checksumCalculator->getVersion() > 0;
 159
 160          unsigned char *ptr;
 161          unsigned char *buf;
 162          const size_t sizeWithoutChecksum = 8 + 4 + 4;
 163          const size_t checksumSize = checksumCalculator->checksumByteSize();
 164          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 165         buf = stream->alloc(totalSize);
 166         ptr = buf;
 167         int tmp = OP_glBindRenderbuffer;memcpy(ptr, &tmp, 4); ptr += 4;
 168         memcpy(ptr, &totalSize, 4);  ptr += 4;
 169
 170                 memcpy(ptr, &target, 4); ptr += 4;
 171                 memcpy(ptr, &renderbuffer, 4); ptr += 4;
 172
 173         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 174         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 175
 176 }
 177
 178 void glBindTexture_enc(void *self , GLenum target, GLuint texture)
 179 {
 180
 181         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 182         IOStream *stream = ctx->m_stream;
 183         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 184         bool useChecksum = checksumCalculator->getVersion() > 0;
 185
 186          unsigned char *ptr;
 187          unsigned char *buf;
 188          const size_t sizeWithoutChecksum = 8 + 4 + 4;
 189          const size_t checksumSize = checksumCalculator->checksumByteSize();
 190          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 191         buf = stream->alloc(totalSize);
 192         ptr = buf;
 193         int tmp = OP_glBindTexture;memcpy(ptr, &tmp, 4); ptr += 4;
 194         memcpy(ptr, &totalSize, 4);  ptr += 4;
 195
 196                 memcpy(ptr, &target, 4); ptr += 4;
 197                 memcpy(ptr, &texture, 4); ptr += 4;
 198
 199         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 200         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 201
 202 }
 203
 204 void glBlendColor_enc(void *self , GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 205 {
 206
 207         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 208         IOStream *stream = ctx->m_stream;
 209         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 210         bool useChecksum = checksumCalculator->getVersion() > 0;
 211
 212          unsigned char *ptr;
 213          unsigned char *buf;
 214          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
 215          const size_t checksumSize = checksumCalculator->checksumByteSize();
 216          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 217         buf = stream->alloc(totalSize);
 218         ptr = buf;
 219         int tmp = OP_glBlendColor;memcpy(ptr, &tmp, 4); ptr += 4;
 220         memcpy(ptr, &totalSize, 4);  ptr += 4;
 221
 222                 memcpy(ptr, &red, 4); ptr += 4;
 223                 memcpy(ptr, &green, 4); ptr += 4;
 224                 memcpy(ptr, &blue, 4); ptr += 4;
 225                 memcpy(ptr, &alpha, 4); ptr += 4;
 226
 227         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 228         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 229
 230 }
 231
 232 void glBlendEquation_enc(void *self , GLenum mode)
 233 {
 234
 235         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 236         IOStream *stream = ctx->m_stream;
 237         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 238         bool useChecksum = checksumCalculator->getVersion() > 0;
 239
 240          unsigned char *ptr;
 241          unsigned char *buf;
 242          const size_t sizeWithoutChecksum = 8 + 4;
 243          const size_t checksumSize = checksumCalculator->checksumByteSize();
 244          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 245         buf = stream->alloc(totalSize);
 246         ptr = buf;
 247         int tmp = OP_glBlendEquation;memcpy(ptr, &tmp, 4); ptr += 4;
 248         memcpy(ptr, &totalSize, 4);  ptr += 4;
 249
 250                 memcpy(ptr, &mode, 4); ptr += 4;
 251
 252         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 253         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 254
 255 }
 256
 257 void glBlendEquationSeparate_enc(void *self , GLenum modeRGB, GLenum modeAlpha)
 258 {
 259
 260         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 261         IOStream *stream = ctx->m_stream;
 262         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 263         bool useChecksum = checksumCalculator->getVersion() > 0;
 264
 265          unsigned char *ptr;
 266          unsigned char *buf;
 267          const size_t sizeWithoutChecksum = 8 + 4 + 4;
 268          const size_t checksumSize = checksumCalculator->checksumByteSize();
 269          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 270         buf = stream->alloc(totalSize);
 271         ptr = buf;
 272         int tmp = OP_glBlendEquationSeparate;memcpy(ptr, &tmp, 4); ptr += 4;
 273         memcpy(ptr, &totalSize, 4);  ptr += 4;
 274
 275                 memcpy(ptr, &modeRGB, 4); ptr += 4;
 276                 memcpy(ptr, &modeAlpha, 4); ptr += 4;
 277
 278         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 279         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 280
 281 }
 282
 283 void glBlendFunc_enc(void *self , GLenum sfactor, GLenum dfactor)
 284 {
 285
 286         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 287         IOStream *stream = ctx->m_stream;
 288         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 289         bool useChecksum = checksumCalculator->getVersion() > 0;
 290
 291          unsigned char *ptr;
 292          unsigned char *buf;
 293          const size_t sizeWithoutChecksum = 8 + 4 + 4;
 294          const size_t checksumSize = checksumCalculator->checksumByteSize();
 295          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 296         buf = stream->alloc(totalSize);
 297         ptr = buf;
 298         int tmp = OP_glBlendFunc;memcpy(ptr, &tmp, 4); ptr += 4;
 299         memcpy(ptr, &totalSize, 4);  ptr += 4;
 300
 301                 memcpy(ptr, &sfactor, 4); ptr += 4;
 302                 memcpy(ptr, &dfactor, 4); ptr += 4;
 303
 304         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 305         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 306
 307 }
 308
 309 void glBlendFuncSeparate_enc(void *self , GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 310 {
 311
 312         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 313         IOStream *stream = ctx->m_stream;
 314         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 315         bool useChecksum = checksumCalculator->getVersion() > 0;
 316
 317          unsigned char *ptr;
 318          unsigned char *buf;
 319          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
 320          const size_t checksumSize = checksumCalculator->checksumByteSize();
 321          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 322         buf = stream->alloc(totalSize);
 323         ptr = buf;
 324         int tmp = OP_glBlendFuncSeparate;memcpy(ptr, &tmp, 4); ptr += 4;
 325         memcpy(ptr, &totalSize, 4);  ptr += 4;
 326
 327                 memcpy(ptr, &srcRGB, 4); ptr += 4;
 328                 memcpy(ptr, &dstRGB, 4); ptr += 4;
 329                 memcpy(ptr, &srcAlpha, 4); ptr += 4;
 330                 memcpy(ptr, &dstAlpha, 4); ptr += 4;
 331
 332         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 333         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 334
 335 }
 336
 337 void glBufferData_enc(void *self , GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
 338 {
 339
 340         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 341         IOStream *stream = ctx->m_stream;
 342         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 343         bool useChecksum = checksumCalculator->getVersion() > 0;
 344
 345         const unsigned int __size_data = ((data != NULL) ?  size : 0);
 346          unsigned char *ptr;
 347          unsigned char *buf;
 348          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_data + 4 + 1*4;
 349          const size_t checksumSize = checksumCalculator->checksumByteSize();
 350          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 351         buf = stream->alloc(8 + 4 + 4);
 352         ptr = buf;
 353         int tmp = OP_glBufferData;memcpy(ptr, &tmp, 4); ptr += 4;
 354         memcpy(ptr, &totalSize, 4);  ptr += 4;
 355
 356                 memcpy(ptr, &target, 4); ptr += 4;
 357                 memcpy(ptr, &size, 4); ptr += 4;
 358
 359         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 360         stream->flush();
 361         stream->writeFully(&__size_data,4);
 362         if (useChecksum) checksumCalculator->addBuffer(&__size_data,4);
 363         if (data != NULL) {
 364                 stream->writeFully(data, __size_data);
 365                 if (useChecksum) checksumCalculator->addBuffer(data, __size_data);
 366         }
 367         buf = stream->alloc(4);
 368         ptr = buf;
 369                 memcpy(ptr, &usage, 4); ptr += 4;
 370
 371         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 372         buf = stream->alloc(checksumSize);
 373         if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
 374
 375 }
 376
 377 void glBufferSubData_enc(void *self , GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
 378 {
 379
 380         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 381         IOStream *stream = ctx->m_stream;
 382         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 383         bool useChecksum = checksumCalculator->getVersion() > 0;
 384
 385         const unsigned int __size_data = ((data != NULL) ?  size : 0);
 386          unsigned char *ptr;
 387          unsigned char *buf;
 388          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_data + 1*4;
 389          const size_t checksumSize = checksumCalculator->checksumByteSize();
 390          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 391         buf = stream->alloc(8 + 4 + 4 + 4);
 392         ptr = buf;
 393         int tmp = OP_glBufferSubData;memcpy(ptr, &tmp, 4); ptr += 4;
 394         memcpy(ptr, &totalSize, 4);  ptr += 4;
 395
 396                 memcpy(ptr, &target, 4); ptr += 4;
 397                 memcpy(ptr, &offset, 4); ptr += 4;
 398                 memcpy(ptr, &size, 4); ptr += 4;
 399
 400         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 401         stream->flush();
 402         stream->writeFully(&__size_data,4);
 403         if (useChecksum) checksumCalculator->addBuffer(&__size_data,4);
 404         if (data != NULL) {
 405                 stream->writeFully(data, __size_data);
 406                 if (useChecksum) checksumCalculator->addBuffer(data, __size_data);
 407         }
 408         buf = stream->alloc(checksumSize);
 409         if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
 410
 411 }
 412
 413 GLenum glCheckFramebufferStatus_enc(void *self , GLenum target)
 414 {
 415
 416         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 417         IOStream *stream = ctx->m_stream;
 418         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 419         bool useChecksum = checksumCalculator->getVersion() > 0;
 420
 421          unsigned char *ptr;
 422          unsigned char *buf;
 423          const size_t sizeWithoutChecksum = 8 + 4;
 424          const size_t checksumSize = checksumCalculator->checksumByteSize();
 425          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 426         buf = stream->alloc(totalSize);
 427         ptr = buf;
 428         int tmp = OP_glCheckFramebufferStatus;memcpy(ptr, &tmp, 4); ptr += 4;
 429         memcpy(ptr, &totalSize, 4);  ptr += 4;
 430
 431                 memcpy(ptr, &target, 4); ptr += 4;
 432
 433         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 434         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 435
 436
 437         GLenum retval;
 438         stream->readback(&retval, 4);
 439         if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
 440         if (useChecksum) {
 441                 unsigned char *checksumBufPtr = NULL;
 442                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
 443                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
 444                 stream->readback(checksumBufPtr, checksumSize);
 445                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
 446                         ALOGE("glCheckFramebufferStatus: GL communication error, please report this issue to b.android.com.\n");
 447                         abort();
 448                 }
 449         }
 450         return retval;
 451 }
 452
 453 void glClear_enc(void *self , GLbitfield mask)
 454 {
 455
 456         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 457         IOStream *stream = ctx->m_stream;
 458         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 459         bool useChecksum = checksumCalculator->getVersion() > 0;
 460
 461          unsigned char *ptr;
 462          unsigned char *buf;
 463          const size_t sizeWithoutChecksum = 8 + 4;
 464          const size_t checksumSize = checksumCalculator->checksumByteSize();
 465          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 466         buf = stream->alloc(totalSize);
 467         ptr = buf;
 468         int tmp = OP_glClear;memcpy(ptr, &tmp, 4); ptr += 4;
 469         memcpy(ptr, &totalSize, 4);  ptr += 4;
 470
 471                 memcpy(ptr, &mask, 4); ptr += 4;
 472
 473         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 474         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 475
 476 }
 477
 478 void glClearColor_enc(void *self , GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 479 {
 480
 481         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 482         IOStream *stream = ctx->m_stream;
 483         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 484         bool useChecksum = checksumCalculator->getVersion() > 0;
 485
 486          unsigned char *ptr;
 487          unsigned char *buf;
 488          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
 489          const size_t checksumSize = checksumCalculator->checksumByteSize();
 490          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 491         buf = stream->alloc(totalSize);
 492         ptr = buf;
 493         int tmp = OP_glClearColor;memcpy(ptr, &tmp, 4); ptr += 4;
 494         memcpy(ptr, &totalSize, 4);  ptr += 4;
 495
 496                 memcpy(ptr, &red, 4); ptr += 4;
 497                 memcpy(ptr, &green, 4); ptr += 4;
 498                 memcpy(ptr, &blue, 4); ptr += 4;
 499                 memcpy(ptr, &alpha, 4); ptr += 4;
 500
 501         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 502         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 503
 504 }
 505
 506 void glClearDepthf_enc(void *self , GLclampf depth)
 507 {
 508
 509         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 510         IOStream *stream = ctx->m_stream;
 511         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 512         bool useChecksum = checksumCalculator->getVersion() > 0;
 513
 514          unsigned char *ptr;
 515          unsigned char *buf;
 516          const size_t sizeWithoutChecksum = 8 + 4;
 517          const size_t checksumSize = checksumCalculator->checksumByteSize();
 518          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 519         buf = stream->alloc(totalSize);
 520         ptr = buf;
 521         int tmp = OP_glClearDepthf;memcpy(ptr, &tmp, 4); ptr += 4;
 522         memcpy(ptr, &totalSize, 4);  ptr += 4;
 523
 524                 memcpy(ptr, &depth, 4); ptr += 4;
 525
 526         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 527         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 528
 529 }
 530
 531 void glClearStencil_enc(void *self , GLint s)
 532 {
 533
 534         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 535         IOStream *stream = ctx->m_stream;
 536         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 537         bool useChecksum = checksumCalculator->getVersion() > 0;
 538
 539          unsigned char *ptr;
 540          unsigned char *buf;
 541          const size_t sizeWithoutChecksum = 8 + 4;
 542          const size_t checksumSize = checksumCalculator->checksumByteSize();
 543          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 544         buf = stream->alloc(totalSize);
 545         ptr = buf;
 546         int tmp = OP_glClearStencil;memcpy(ptr, &tmp, 4); ptr += 4;
 547         memcpy(ptr, &totalSize, 4);  ptr += 4;
 548
 549                 memcpy(ptr, &s, 4); ptr += 4;
 550
 551         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 552         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 553
 554 }
 555
 556 void glColorMask_enc(void *self , GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 557 {
 558
 559         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 560         IOStream *stream = ctx->m_stream;
 561         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 562         bool useChecksum = checksumCalculator->getVersion() > 0;
 563
 564          unsigned char *ptr;
 565          unsigned char *buf;
 566          const size_t sizeWithoutChecksum = 8 + 1 + 1 + 1 + 1;
 567          const size_t checksumSize = checksumCalculator->checksumByteSize();
 568          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 569         buf = stream->alloc(totalSize);
 570         ptr = buf;
 571         int tmp = OP_glColorMask;memcpy(ptr, &tmp, 4); ptr += 4;
 572         memcpy(ptr, &totalSize, 4);  ptr += 4;
 573
 574                 memcpy(ptr, &red, 1); ptr += 1;
 575                 memcpy(ptr, &green, 1); ptr += 1;
 576                 memcpy(ptr, &blue, 1); ptr += 1;
 577                 memcpy(ptr, &alpha, 1); ptr += 1;
 578
 579         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 580         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 581
 582 }
 583
 584 void glCompileShader_enc(void *self , GLuint shader)
 585 {
 586
 587         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 588         IOStream *stream = ctx->m_stream;
 589         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 590         bool useChecksum = checksumCalculator->getVersion() > 0;
 591
 592          unsigned char *ptr;
 593          unsigned char *buf;
 594          const size_t sizeWithoutChecksum = 8 + 4;
 595          const size_t checksumSize = checksumCalculator->checksumByteSize();
 596          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 597         buf = stream->alloc(totalSize);
 598         ptr = buf;
 599         int tmp = OP_glCompileShader;memcpy(ptr, &tmp, 4); ptr += 4;
 600         memcpy(ptr, &totalSize, 4);  ptr += 4;
 601
 602                 memcpy(ptr, &shader, 4); ptr += 4;
 603
 604         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 605         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 606
 607 }
 608
 609 void glCompressedTexImage2D_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data)
 610 {
 611
 612         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 613         IOStream *stream = ctx->m_stream;
 614         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 615         bool useChecksum = checksumCalculator->getVersion() > 0;
 616
 617         const unsigned int __size_data = ((data != NULL) ?  imageSize : 0);
 618          unsigned char *ptr;
 619          unsigned char *buf;
 620          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_data + 1*4;
 621          const size_t checksumSize = checksumCalculator->checksumByteSize();
 622          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 623         buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
 624         ptr = buf;
 625         int tmp = OP_glCompressedTexImage2D;memcpy(ptr, &tmp, 4); ptr += 4;
 626         memcpy(ptr, &totalSize, 4);  ptr += 4;
 627
 628                 memcpy(ptr, &target, 4); ptr += 4;
 629                 memcpy(ptr, &level, 4); ptr += 4;
 630                 memcpy(ptr, &internalformat, 4); ptr += 4;
 631                 memcpy(ptr, &width, 4); ptr += 4;
 632                 memcpy(ptr, &height, 4); ptr += 4;
 633                 memcpy(ptr, &border, 4); ptr += 4;
 634                 memcpy(ptr, &imageSize, 4); ptr += 4;
 635
 636         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 637         stream->flush();
 638         stream->writeFully(&__size_data,4);
 639         if (useChecksum) checksumCalculator->addBuffer(&__size_data,4);
 640         if (data != NULL) {
 641                 stream->writeFully(data, __size_data);
 642                 if (useChecksum) checksumCalculator->addBuffer(data, __size_data);
 643         }
 644         buf = stream->alloc(checksumSize);
 645         if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
 646
 647 }
 648
 649 void glCompressedTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data)
 650 {
 651
 652         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 653         IOStream *stream = ctx->m_stream;
 654         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 655         bool useChecksum = checksumCalculator->getVersion() > 0;
 656
 657         const unsigned int __size_data = ((data != NULL) ?  imageSize : 0);
 658          unsigned char *ptr;
 659          unsigned char *buf;
 660          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_data + 1*4;
 661          const size_t checksumSize = checksumCalculator->checksumByteSize();
 662          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 663         buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
 664         ptr = buf;
 665         int tmp = OP_glCompressedTexSubImage2D;memcpy(ptr, &tmp, 4); ptr += 4;
 666         memcpy(ptr, &totalSize, 4);  ptr += 4;
 667
 668                 memcpy(ptr, &target, 4); ptr += 4;
 669                 memcpy(ptr, &level, 4); ptr += 4;
 670                 memcpy(ptr, &xoffset, 4); ptr += 4;
 671                 memcpy(ptr, &yoffset, 4); ptr += 4;
 672                 memcpy(ptr, &width, 4); ptr += 4;
 673                 memcpy(ptr, &height, 4); ptr += 4;
 674                 memcpy(ptr, &format, 4); ptr += 4;
 675                 memcpy(ptr, &imageSize, 4); ptr += 4;
 676
 677         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 678         stream->flush();
 679         stream->writeFully(&__size_data,4);
 680         if (useChecksum) checksumCalculator->addBuffer(&__size_data,4);
 681         if (data != NULL) {
 682                 stream->writeFully(data, __size_data);
 683                 if (useChecksum) checksumCalculator->addBuffer(data, __size_data);
 684         }
 685         buf = stream->alloc(checksumSize);
 686         if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
 687
 688 }
 689
 690 void glCopyTexImage2D_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 691 {
 692
 693         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 694         IOStream *stream = ctx->m_stream;
 695         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 696         bool useChecksum = checksumCalculator->getVersion() > 0;
 697
 698          unsigned char *ptr;
 699          unsigned char *buf;
 700          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4;
 701          const size_t checksumSize = checksumCalculator->checksumByteSize();
 702          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 703         buf = stream->alloc(totalSize);
 704         ptr = buf;
 705         int tmp = OP_glCopyTexImage2D;memcpy(ptr, &tmp, 4); ptr += 4;
 706         memcpy(ptr, &totalSize, 4);  ptr += 4;
 707
 708                 memcpy(ptr, &target, 4); ptr += 4;
 709                 memcpy(ptr, &level, 4); ptr += 4;
 710                 memcpy(ptr, &internalformat, 4); ptr += 4;
 711                 memcpy(ptr, &x, 4); ptr += 4;
 712                 memcpy(ptr, &y, 4); ptr += 4;
 713                 memcpy(ptr, &width, 4); ptr += 4;
 714                 memcpy(ptr, &height, 4); ptr += 4;
 715                 memcpy(ptr, &border, 4); ptr += 4;
 716
 717         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 718         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 719
 720 }
 721
 722 void glCopyTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 723 {
 724
 725         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 726         IOStream *stream = ctx->m_stream;
 727         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 728         bool useChecksum = checksumCalculator->getVersion() > 0;
 729
 730          unsigned char *ptr;
 731          unsigned char *buf;
 732          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4;
 733          const size_t checksumSize = checksumCalculator->checksumByteSize();
 734          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 735         buf = stream->alloc(totalSize);
 736         ptr = buf;
 737         int tmp = OP_glCopyTexSubImage2D;memcpy(ptr, &tmp, 4); ptr += 4;
 738         memcpy(ptr, &totalSize, 4);  ptr += 4;
 739
 740                 memcpy(ptr, &target, 4); ptr += 4;
 741                 memcpy(ptr, &level, 4); ptr += 4;
 742                 memcpy(ptr, &xoffset, 4); ptr += 4;
 743                 memcpy(ptr, &yoffset, 4); ptr += 4;
 744                 memcpy(ptr, &x, 4); ptr += 4;
 745                 memcpy(ptr, &y, 4); ptr += 4;
 746                 memcpy(ptr, &width, 4); ptr += 4;
 747                 memcpy(ptr, &height, 4); ptr += 4;
 748
 749         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 750         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 751
 752 }
 753
 754 GLuint glCreateProgram_enc(void *self )
 755 {
 756
 757         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 758         IOStream *stream = ctx->m_stream;
 759         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 760         bool useChecksum = checksumCalculator->getVersion() > 0;
 761
 762          unsigned char *ptr;
 763          unsigned char *buf;
 764          const size_t sizeWithoutChecksum = 8;
 765          const size_t checksumSize = checksumCalculator->checksumByteSize();
 766          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 767         buf = stream->alloc(totalSize);
 768         ptr = buf;
 769         int tmp = OP_glCreateProgram;memcpy(ptr, &tmp, 4); ptr += 4;
 770         memcpy(ptr, &totalSize, 4);  ptr += 4;
 771
 772
 773         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 774         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 775
 776
 777         GLuint retval;
 778         stream->readback(&retval, 4);
 779         if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
 780         if (useChecksum) {
 781                 unsigned char *checksumBufPtr = NULL;
 782                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
 783                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
 784                 stream->readback(checksumBufPtr, checksumSize);
 785                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
 786                         ALOGE("glCreateProgram: GL communication error, please report this issue to b.android.com.\n");
 787                         abort();
 788                 }
 789         }
 790         return retval;
 791 }
 792
 793 GLuint glCreateShader_enc(void *self , GLenum type)
 794 {
 795
 796         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 797         IOStream *stream = ctx->m_stream;
 798         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 799         bool useChecksum = checksumCalculator->getVersion() > 0;
 800
 801          unsigned char *ptr;
 802          unsigned char *buf;
 803          const size_t sizeWithoutChecksum = 8 + 4;
 804          const size_t checksumSize = checksumCalculator->checksumByteSize();
 805          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 806         buf = stream->alloc(totalSize);
 807         ptr = buf;
 808         int tmp = OP_glCreateShader;memcpy(ptr, &tmp, 4); ptr += 4;
 809         memcpy(ptr, &totalSize, 4);  ptr += 4;
 810
 811                 memcpy(ptr, &type, 4); ptr += 4;
 812
 813         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 814         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 815
 816
 817         GLuint retval;
 818         stream->readback(&retval, 4);
 819         if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
 820         if (useChecksum) {
 821                 unsigned char *checksumBufPtr = NULL;
 822                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
 823                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
 824                 stream->readback(checksumBufPtr, checksumSize);
 825                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
 826                         ALOGE("glCreateShader: GL communication error, please report this issue to b.android.com.\n");
 827                         abort();
 828                 }
 829         }
 830         return retval;
 831 }
 832
 833 void glCullFace_enc(void *self , GLenum mode)
 834 {
 835
 836         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 837         IOStream *stream = ctx->m_stream;
 838         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 839         bool useChecksum = checksumCalculator->getVersion() > 0;
 840
 841          unsigned char *ptr;
 842          unsigned char *buf;
 843          const size_t sizeWithoutChecksum = 8 + 4;
 844          const size_t checksumSize = checksumCalculator->checksumByteSize();
 845          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 846         buf = stream->alloc(totalSize);
 847         ptr = buf;
 848         int tmp = OP_glCullFace;memcpy(ptr, &tmp, 4); ptr += 4;
 849         memcpy(ptr, &totalSize, 4);  ptr += 4;
 850
 851                 memcpy(ptr, &mode, 4); ptr += 4;
 852
 853         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 854         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 855
 856 }
 857
 858 void glDeleteBuffers_enc(void *self , GLsizei n, const GLuint* buffers)
 859 {
 860
 861         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 862         IOStream *stream = ctx->m_stream;
 863         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 864         bool useChecksum = checksumCalculator->getVersion() > 0;
 865
 866         const unsigned int __size_buffers =  (n * sizeof(GLuint));
 867          unsigned char *ptr;
 868          unsigned char *buf;
 869          const size_t sizeWithoutChecksum = 8 + 4 + __size_buffers + 1*4;
 870          const size_t checksumSize = checksumCalculator->checksumByteSize();
 871          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 872         buf = stream->alloc(totalSize);
 873         ptr = buf;
 874         int tmp = OP_glDeleteBuffers;memcpy(ptr, &tmp, 4); ptr += 4;
 875         memcpy(ptr, &totalSize, 4);  ptr += 4;
 876
 877                 memcpy(ptr, &n, 4); ptr += 4;
 878         *(unsigned int *)(ptr) = __size_buffers; ptr += 4;
 879         memcpy(ptr, buffers, __size_buffers);ptr += __size_buffers;
 880
 881         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 882         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 883
 884 }
 885
 886 void glDeleteFramebuffers_enc(void *self , GLsizei n, const GLuint* framebuffers)
 887 {
 888
 889         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 890         IOStream *stream = ctx->m_stream;
 891         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 892         bool useChecksum = checksumCalculator->getVersion() > 0;
 893
 894         const unsigned int __size_framebuffers =  (n * sizeof(GLuint));
 895          unsigned char *ptr;
 896          unsigned char *buf;
 897          const size_t sizeWithoutChecksum = 8 + 4 + __size_framebuffers + 1*4;
 898          const size_t checksumSize = checksumCalculator->checksumByteSize();
 899          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 900         buf = stream->alloc(totalSize);
 901         ptr = buf;
 902         int tmp = OP_glDeleteFramebuffers;memcpy(ptr, &tmp, 4); ptr += 4;
 903         memcpy(ptr, &totalSize, 4);  ptr += 4;
 904
 905                 memcpy(ptr, &n, 4); ptr += 4;
 906         *(unsigned int *)(ptr) = __size_framebuffers; ptr += 4;
 907         memcpy(ptr, framebuffers, __size_framebuffers);ptr += __size_framebuffers;
 908
 909         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 910         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 911
 912 }
 913
 914 void glDeleteProgram_enc(void *self , GLuint program)
 915 {
 916
 917         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 918         IOStream *stream = ctx->m_stream;
 919         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 920         bool useChecksum = checksumCalculator->getVersion() > 0;
 921
 922          unsigned char *ptr;
 923          unsigned char *buf;
 924          const size_t sizeWithoutChecksum = 8 + 4;
 925          const size_t checksumSize = checksumCalculator->checksumByteSize();
 926          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 927         buf = stream->alloc(totalSize);
 928         ptr = buf;
 929         int tmp = OP_glDeleteProgram;memcpy(ptr, &tmp, 4); ptr += 4;
 930         memcpy(ptr, &totalSize, 4);  ptr += 4;
 931
 932                 memcpy(ptr, &program, 4); ptr += 4;
 933
 934         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 935         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 936
 937 }
 938
 939 void glDeleteRenderbuffers_enc(void *self , GLsizei n, const GLuint* renderbuffers)
 940 {
 941
 942         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 943         IOStream *stream = ctx->m_stream;
 944         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 945         bool useChecksum = checksumCalculator->getVersion() > 0;
 946
 947         const unsigned int __size_renderbuffers =  (n * sizeof(GLuint));
 948          unsigned char *ptr;
 949          unsigned char *buf;
 950          const size_t sizeWithoutChecksum = 8 + 4 + __size_renderbuffers + 1*4;
 951          const size_t checksumSize = checksumCalculator->checksumByteSize();
 952          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 953         buf = stream->alloc(totalSize);
 954         ptr = buf;
 955         int tmp = OP_glDeleteRenderbuffers;memcpy(ptr, &tmp, 4); ptr += 4;
 956         memcpy(ptr, &totalSize, 4);  ptr += 4;
 957
 958                 memcpy(ptr, &n, 4); ptr += 4;
 959         *(unsigned int *)(ptr) = __size_renderbuffers; ptr += 4;
 960         memcpy(ptr, renderbuffers, __size_renderbuffers);ptr += __size_renderbuffers;
 961
 962         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 963         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 964
 965 }
 966
 967 void glDeleteShader_enc(void *self , GLuint shader)
 968 {
 969
 970         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 971         IOStream *stream = ctx->m_stream;
 972         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 973         bool useChecksum = checksumCalculator->getVersion() > 0;
 974
 975          unsigned char *ptr;
 976          unsigned char *buf;
 977          const size_t sizeWithoutChecksum = 8 + 4;
 978          const size_t checksumSize = checksumCalculator->checksumByteSize();
 979          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 980         buf = stream->alloc(totalSize);
 981         ptr = buf;
 982         int tmp = OP_glDeleteShader;memcpy(ptr, &tmp, 4); ptr += 4;
 983         memcpy(ptr, &totalSize, 4);  ptr += 4;
 984
 985                 memcpy(ptr, &shader, 4); ptr += 4;
 986
 987         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 988         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 989
 990 }
 991
 992 void glDeleteTextures_enc(void *self , GLsizei n, const GLuint* textures)
 993 {
 994
 995         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 996         IOStream *stream = ctx->m_stream;
 997         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 998         bool useChecksum = checksumCalculator->getVersion() > 0;
 999
1000         const unsigned int __size_textures =  (n * sizeof(GLuint));
1001          unsigned char *ptr;
1002          unsigned char *buf;
1003          const size_t sizeWithoutChecksum = 8 + 4 + __size_textures + 1*4;
1004          const size_t checksumSize = checksumCalculator->checksumByteSize();
1005          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1006         buf = stream->alloc(totalSize);
1007         ptr = buf;
1008         int tmp = OP_glDeleteTextures;memcpy(ptr, &tmp, 4); ptr += 4;
1009         memcpy(ptr, &totalSize, 4);  ptr += 4;
1010
1011                 memcpy(ptr, &n, 4); ptr += 4;
1012         *(unsigned int *)(ptr) = __size_textures; ptr += 4;
1013         memcpy(ptr, textures, __size_textures);ptr += __size_textures;
1014
1015         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1016         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1017
1018 }
1019
1020 void glDepthFunc_enc(void *self , GLenum func)
1021 {
1022
1023         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1024         IOStream *stream = ctx->m_stream;
1025         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1026         bool useChecksum = checksumCalculator->getVersion() > 0;
1027
1028          unsigned char *ptr;
1029          unsigned char *buf;
1030          const size_t sizeWithoutChecksum = 8 + 4;
1031          const size_t checksumSize = checksumCalculator->checksumByteSize();
1032          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1033         buf = stream->alloc(totalSize);
1034         ptr = buf;
1035         int tmp = OP_glDepthFunc;memcpy(ptr, &tmp, 4); ptr += 4;
1036         memcpy(ptr, &totalSize, 4);  ptr += 4;
1037
1038                 memcpy(ptr, &func, 4); ptr += 4;
1039
1040         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1041         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1042
1043 }
1044
1045 void glDepthMask_enc(void *self , GLboolean flag)
1046 {
1047
1048         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1049         IOStream *stream = ctx->m_stream;
1050         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1051         bool useChecksum = checksumCalculator->getVersion() > 0;
1052
1053          unsigned char *ptr;
1054          unsigned char *buf;
1055          const size_t sizeWithoutChecksum = 8 + 1;
1056          const size_t checksumSize = checksumCalculator->checksumByteSize();
1057          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1058         buf = stream->alloc(totalSize);
1059         ptr = buf;
1060         int tmp = OP_glDepthMask;memcpy(ptr, &tmp, 4); ptr += 4;
1061         memcpy(ptr, &totalSize, 4);  ptr += 4;
1062
1063                 memcpy(ptr, &flag, 1); ptr += 1;
1064
1065         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1066         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1067
1068 }
1069
1070 void glDepthRangef_enc(void *self , GLclampf zNear, GLclampf zFar)
1071 {
1072
1073         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1074         IOStream *stream = ctx->m_stream;
1075         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1076         bool useChecksum = checksumCalculator->getVersion() > 0;
1077
1078          unsigned char *ptr;
1079          unsigned char *buf;
1080          const size_t sizeWithoutChecksum = 8 + 4 + 4;
1081          const size_t checksumSize = checksumCalculator->checksumByteSize();
1082          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1083         buf = stream->alloc(totalSize);
1084         ptr = buf;
1085         int tmp = OP_glDepthRangef;memcpy(ptr, &tmp, 4); ptr += 4;
1086         memcpy(ptr, &totalSize, 4);  ptr += 4;
1087
1088                 memcpy(ptr, &zNear, 4); ptr += 4;
1089                 memcpy(ptr, &zFar, 4); ptr += 4;
1090
1091         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1092         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1093
1094 }
1095
1096 void glDetachShader_enc(void *self , GLuint program, GLuint shader)
1097 {
1098
1099         gl2_encoder_context_t *ctx = (gl2_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 + 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_glDetachShader;memcpy(ptr, &tmp, 4); ptr += 4;
1112         memcpy(ptr, &totalSize, 4);  ptr += 4;
1113
1114                 memcpy(ptr, &program, 4); ptr += 4;
1115                 memcpy(ptr, &shader, 4); ptr += 4;
1116
1117         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1118         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1119
1120 }
1121
1122 void glDisable_enc(void *self , GLenum cap)
1123 {
1124
1125         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1126         IOStream *stream = ctx->m_stream;
1127         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1128         bool useChecksum = checksumCalculator->getVersion() > 0;
1129
1130          unsigned char *ptr;
1131          unsigned char *buf;
1132          const size_t sizeWithoutChecksum = 8 + 4;
1133          const size_t checksumSize = checksumCalculator->checksumByteSize();
1134          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1135         buf = stream->alloc(totalSize);
1136         ptr = buf;
1137         int tmp = OP_glDisable;memcpy(ptr, &tmp, 4); ptr += 4;
1138         memcpy(ptr, &totalSize, 4);  ptr += 4;
1139
1140                 memcpy(ptr, &cap, 4); ptr += 4;
1141
1142         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1143         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1144
1145 }
1146
1147 void glDisableVertexAttribArray_enc(void *self , GLuint index)
1148 {
1149
1150         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1151         IOStream *stream = ctx->m_stream;
1152         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1153         bool useChecksum = checksumCalculator->getVersion() > 0;
1154
1155          unsigned char *ptr;
1156          unsigned char *buf;
1157          const size_t sizeWithoutChecksum = 8 + 4;
1158          const size_t checksumSize = checksumCalculator->checksumByteSize();
1159          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1160         buf = stream->alloc(totalSize);
1161         ptr = buf;
1162         int tmp = OP_glDisableVertexAttribArray;memcpy(ptr, &tmp, 4); ptr += 4;
1163         memcpy(ptr, &totalSize, 4);  ptr += 4;
1164
1165                 memcpy(ptr, &index, 4); ptr += 4;
1166
1167         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1168         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1169
1170 }
1171
1172 void glDrawArrays_enc(void *self , GLenum mode, GLint first, GLsizei count)
1173 {
1174
1175         gl2_encoder_context_t *ctx = (gl2_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 + 4 + 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_glDrawArrays;memcpy(ptr, &tmp, 4); ptr += 4;
1188         memcpy(ptr, &totalSize, 4);  ptr += 4;
1189
1190                 memcpy(ptr, &mode, 4); ptr += 4;
1191                 memcpy(ptr, &first, 4); ptr += 4;
1192                 memcpy(ptr, &count, 4); ptr += 4;
1193
1194         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1195         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1196
1197 }
1198
1199 void glEnable_enc(void *self , GLenum cap)
1200 {
1201
1202         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1203         IOStream *stream = ctx->m_stream;
1204         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1205         bool useChecksum = checksumCalculator->getVersion() > 0;
1206
1207          unsigned char *ptr;
1208          unsigned char *buf;
1209          const size_t sizeWithoutChecksum = 8 + 4;
1210          const size_t checksumSize = checksumCalculator->checksumByteSize();
1211          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1212         buf = stream->alloc(totalSize);
1213         ptr = buf;
1214         int tmp = OP_glEnable;memcpy(ptr, &tmp, 4); ptr += 4;
1215         memcpy(ptr, &totalSize, 4);  ptr += 4;
1216
1217                 memcpy(ptr, &cap, 4); ptr += 4;
1218
1219         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1220         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1221
1222 }
1223
1224 void glEnableVertexAttribArray_enc(void *self , GLuint index)
1225 {
1226
1227         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1228         IOStream *stream = ctx->m_stream;
1229         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1230         bool useChecksum = checksumCalculator->getVersion() > 0;
1231
1232          unsigned char *ptr;
1233          unsigned char *buf;
1234          const size_t sizeWithoutChecksum = 8 + 4;
1235          const size_t checksumSize = checksumCalculator->checksumByteSize();
1236          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1237         buf = stream->alloc(totalSize);
1238         ptr = buf;
1239         int tmp = OP_glEnableVertexAttribArray;memcpy(ptr, &tmp, 4); ptr += 4;
1240         memcpy(ptr, &totalSize, 4);  ptr += 4;
1241
1242                 memcpy(ptr, &index, 4); ptr += 4;
1243
1244         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1245         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1246
1247 }
1248
1249 void glFinish_enc(void *self )
1250 {
1251
1252         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1253         IOStream *stream = ctx->m_stream;
1254         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1255         bool useChecksum = checksumCalculator->getVersion() > 0;
1256
1257          unsigned char *ptr;
1258          unsigned char *buf;
1259          const size_t sizeWithoutChecksum = 8;
1260          const size_t checksumSize = checksumCalculator->checksumByteSize();
1261          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1262         buf = stream->alloc(totalSize);
1263         ptr = buf;
1264         int tmp = OP_glFinish;memcpy(ptr, &tmp, 4); ptr += 4;
1265         memcpy(ptr, &totalSize, 4);  ptr += 4;
1266
1267
1268         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1269         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1270
1271 }
1272
1273 void glFlush_enc(void *self )
1274 {
1275
1276         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1277         IOStream *stream = ctx->m_stream;
1278         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1279         bool useChecksum = checksumCalculator->getVersion() > 0;
1280
1281          unsigned char *ptr;
1282          unsigned char *buf;
1283          const size_t sizeWithoutChecksum = 8;
1284          const size_t checksumSize = checksumCalculator->checksumByteSize();
1285          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1286         buf = stream->alloc(totalSize);
1287         ptr = buf;
1288         int tmp = OP_glFlush;memcpy(ptr, &tmp, 4); ptr += 4;
1289         memcpy(ptr, &totalSize, 4);  ptr += 4;
1290
1291
1292         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1293         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1294
1295 }
1296
1297 void glFramebufferRenderbuffer_enc(void *self , GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
1298 {
1299
1300         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1301         IOStream *stream = ctx->m_stream;
1302         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1303         bool useChecksum = checksumCalculator->getVersion() > 0;
1304
1305          unsigned char *ptr;
1306          unsigned char *buf;
1307          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
1308          const size_t checksumSize = checksumCalculator->checksumByteSize();
1309          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1310         buf = stream->alloc(totalSize);
1311         ptr = buf;
1312         int tmp = OP_glFramebufferRenderbuffer;memcpy(ptr, &tmp, 4); ptr += 4;
1313         memcpy(ptr, &totalSize, 4);  ptr += 4;
1314
1315                 memcpy(ptr, &target, 4); ptr += 4;
1316                 memcpy(ptr, &attachment, 4); ptr += 4;
1317                 memcpy(ptr, &renderbuffertarget, 4); ptr += 4;
1318                 memcpy(ptr, &renderbuffer, 4); ptr += 4;
1319
1320         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1321         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1322
1323 }
1324
1325 void glFramebufferTexture2D_enc(void *self , GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1326 {
1327
1328         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1329         IOStream *stream = ctx->m_stream;
1330         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1331         bool useChecksum = checksumCalculator->getVersion() > 0;
1332
1333          unsigned char *ptr;
1334          unsigned char *buf;
1335          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
1336          const size_t checksumSize = checksumCalculator->checksumByteSize();
1337          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1338         buf = stream->alloc(totalSize);
1339         ptr = buf;
1340         int tmp = OP_glFramebufferTexture2D;memcpy(ptr, &tmp, 4); ptr += 4;
1341         memcpy(ptr, &totalSize, 4);  ptr += 4;
1342
1343                 memcpy(ptr, &target, 4); ptr += 4;
1344                 memcpy(ptr, &attachment, 4); ptr += 4;
1345                 memcpy(ptr, &textarget, 4); ptr += 4;
1346                 memcpy(ptr, &texture, 4); ptr += 4;
1347                 memcpy(ptr, &level, 4); ptr += 4;
1348
1349         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1350         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1351
1352 }
1353
1354 void glFrontFace_enc(void *self , GLenum mode)
1355 {
1356
1357         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1358         IOStream *stream = ctx->m_stream;
1359         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1360         bool useChecksum = checksumCalculator->getVersion() > 0;
1361
1362          unsigned char *ptr;
1363          unsigned char *buf;
1364          const size_t sizeWithoutChecksum = 8 + 4;
1365          const size_t checksumSize = checksumCalculator->checksumByteSize();
1366          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1367         buf = stream->alloc(totalSize);
1368         ptr = buf;
1369         int tmp = OP_glFrontFace;memcpy(ptr, &tmp, 4); ptr += 4;
1370         memcpy(ptr, &totalSize, 4);  ptr += 4;
1371
1372                 memcpy(ptr, &mode, 4); ptr += 4;
1373
1374         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1375         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1376
1377 }
1378
1379 void glGenBuffers_enc(void *self , GLsizei n, GLuint* buffers)
1380 {
1381
1382         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1383         IOStream *stream = ctx->m_stream;
1384         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1385         bool useChecksum = checksumCalculator->getVersion() > 0;
1386
1387         const unsigned int __size_buffers =  (n * sizeof(GLuint));
1388          unsigned char *ptr;
1389          unsigned char *buf;
1390          const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
1391          const size_t checksumSize = checksumCalculator->checksumByteSize();
1392          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1393         buf = stream->alloc(totalSize);
1394         ptr = buf;
1395         int tmp = OP_glGenBuffers;memcpy(ptr, &tmp, 4); ptr += 4;
1396         memcpy(ptr, &totalSize, 4);  ptr += 4;
1397
1398                 memcpy(ptr, &n, 4); ptr += 4;
1399         *(unsigned int *)(ptr) = __size_buffers; ptr += 4;
1400
1401         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1402         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1403
1404         stream->readback(buffers, __size_buffers);
1405         if (useChecksum) checksumCalculator->addBuffer(buffers, __size_buffers);
1406         if (useChecksum) {
1407                 unsigned char *checksumBufPtr = NULL;
1408                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1409                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1410                 stream->readback(checksumBufPtr, checksumSize);
1411                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1412                         ALOGE("glGenBuffers: GL communication error, please report this issue to b.android.com.\n");
1413                         abort();
1414                 }
1415         }
1416 }
1417
1418 void glGenerateMipmap_enc(void *self , GLenum target)
1419 {
1420
1421         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1422         IOStream *stream = ctx->m_stream;
1423         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1424         bool useChecksum = checksumCalculator->getVersion() > 0;
1425
1426          unsigned char *ptr;
1427          unsigned char *buf;
1428          const size_t sizeWithoutChecksum = 8 + 4;
1429          const size_t checksumSize = checksumCalculator->checksumByteSize();
1430          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1431         buf = stream->alloc(totalSize);
1432         ptr = buf;
1433         int tmp = OP_glGenerateMipmap;memcpy(ptr, &tmp, 4); ptr += 4;
1434         memcpy(ptr, &totalSize, 4);  ptr += 4;
1435
1436                 memcpy(ptr, &target, 4); ptr += 4;
1437
1438         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1439         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1440
1441 }
1442
1443 void glGenFramebuffers_enc(void *self , GLsizei n, GLuint* framebuffers)
1444 {
1445
1446         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1447         IOStream *stream = ctx->m_stream;
1448         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1449         bool useChecksum = checksumCalculator->getVersion() > 0;
1450
1451         const unsigned int __size_framebuffers =  (n * sizeof(GLuint));
1452          unsigned char *ptr;
1453          unsigned char *buf;
1454          const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
1455          const size_t checksumSize = checksumCalculator->checksumByteSize();
1456          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1457         buf = stream->alloc(totalSize);
1458         ptr = buf;
1459         int tmp = OP_glGenFramebuffers;memcpy(ptr, &tmp, 4); ptr += 4;
1460         memcpy(ptr, &totalSize, 4);  ptr += 4;
1461
1462                 memcpy(ptr, &n, 4); ptr += 4;
1463         *(unsigned int *)(ptr) = __size_framebuffers; ptr += 4;
1464
1465         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1466         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1467
1468         stream->readback(framebuffers, __size_framebuffers);
1469         if (useChecksum) checksumCalculator->addBuffer(framebuffers, __size_framebuffers);
1470         if (useChecksum) {
1471                 unsigned char *checksumBufPtr = NULL;
1472                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1473                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1474                 stream->readback(checksumBufPtr, checksumSize);
1475                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1476                         ALOGE("glGenFramebuffers: GL communication error, please report this issue to b.android.com.\n");
1477                         abort();
1478                 }
1479         }
1480 }
1481
1482 void glGenRenderbuffers_enc(void *self , GLsizei n, GLuint* renderbuffers)
1483 {
1484
1485         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1486         IOStream *stream = ctx->m_stream;
1487         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1488         bool useChecksum = checksumCalculator->getVersion() > 0;
1489
1490         const unsigned int __size_renderbuffers =  (n * sizeof(GLuint));
1491          unsigned char *ptr;
1492          unsigned char *buf;
1493          const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
1494          const size_t checksumSize = checksumCalculator->checksumByteSize();
1495          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1496         buf = stream->alloc(totalSize);
1497         ptr = buf;
1498         int tmp = OP_glGenRenderbuffers;memcpy(ptr, &tmp, 4); ptr += 4;
1499         memcpy(ptr, &totalSize, 4);  ptr += 4;
1500
1501                 memcpy(ptr, &n, 4); ptr += 4;
1502         *(unsigned int *)(ptr) = __size_renderbuffers; ptr += 4;
1503
1504         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1505         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1506
1507         stream->readback(renderbuffers, __size_renderbuffers);
1508         if (useChecksum) checksumCalculator->addBuffer(renderbuffers, __size_renderbuffers);
1509         if (useChecksum) {
1510                 unsigned char *checksumBufPtr = NULL;
1511                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1512                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1513                 stream->readback(checksumBufPtr, checksumSize);
1514                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1515                         ALOGE("glGenRenderbuffers: GL communication error, please report this issue to b.android.com.\n");
1516                         abort();
1517                 }
1518         }
1519 }
1520
1521 void glGenTextures_enc(void *self , GLsizei n, GLuint* textures)
1522 {
1523
1524         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1525         IOStream *stream = ctx->m_stream;
1526         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1527         bool useChecksum = checksumCalculator->getVersion() > 0;
1528
1529         const unsigned int __size_textures =  (n * sizeof(GLuint));
1530          unsigned char *ptr;
1531          unsigned char *buf;
1532          const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
1533          const size_t checksumSize = checksumCalculator->checksumByteSize();
1534          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1535         buf = stream->alloc(totalSize);
1536         ptr = buf;
1537         int tmp = OP_glGenTextures;memcpy(ptr, &tmp, 4); ptr += 4;
1538         memcpy(ptr, &totalSize, 4);  ptr += 4;
1539
1540                 memcpy(ptr, &n, 4); ptr += 4;
1541         *(unsigned int *)(ptr) = __size_textures; ptr += 4;
1542
1543         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1544         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1545
1546         stream->readback(textures, __size_textures);
1547         if (useChecksum) checksumCalculator->addBuffer(textures, __size_textures);
1548         if (useChecksum) {
1549                 unsigned char *checksumBufPtr = NULL;
1550                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1551                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1552                 stream->readback(checksumBufPtr, checksumSize);
1553                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1554                         ALOGE("glGenTextures: GL communication error, please report this issue to b.android.com.\n");
1555                         abort();
1556                 }
1557         }
1558 }
1559
1560 void glGetActiveAttrib_enc(void *self , GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
1561 {
1562
1563         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1564         IOStream *stream = ctx->m_stream;
1565         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1566         bool useChecksum = checksumCalculator->getVersion() > 0;
1567
1568         const unsigned int __size_length = ((length != NULL) ?  (sizeof(GLsizei)) : 0);
1569         const unsigned int __size_size = ((size != NULL) ?  (sizeof(GLint)) : 0);
1570         const unsigned int __size_type = ((type != NULL) ?  (sizeof(GLenum)) : 0);
1571         const unsigned int __size_name = ((name != NULL) ?  bufsize : 0);
1572          unsigned char *ptr;
1573          unsigned char *buf;
1574          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 0 + 0 + 0 + 0 + 4*4;
1575          const size_t checksumSize = checksumCalculator->checksumByteSize();
1576          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1577         buf = stream->alloc(totalSize);
1578         ptr = buf;
1579         int tmp = OP_glGetActiveAttrib;memcpy(ptr, &tmp, 4); ptr += 4;
1580         memcpy(ptr, &totalSize, 4);  ptr += 4;
1581
1582                 memcpy(ptr, &program, 4); ptr += 4;
1583                 memcpy(ptr, &index, 4); ptr += 4;
1584                 memcpy(ptr, &bufsize, 4); ptr += 4;
1585         *(unsigned int *)(ptr) = __size_length; ptr += 4;
1586         *(unsigned int *)(ptr) = __size_size; ptr += 4;
1587         *(unsigned int *)(ptr) = __size_type; ptr += 4;
1588         *(unsigned int *)(ptr) = __size_name; ptr += 4;
1589
1590         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1591         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1592
1593         if (length != NULL) {
1594                 stream->readback(length, __size_length);
1595                 if (useChecksum) checksumCalculator->addBuffer(length, __size_length);
1596         }
1597         if (size != NULL) {
1598                 stream->readback(size, __size_size);
1599                 if (useChecksum) checksumCalculator->addBuffer(size, __size_size);
1600         }
1601         if (type != NULL) {
1602                 stream->readback(type, __size_type);
1603                 if (useChecksum) checksumCalculator->addBuffer(type, __size_type);
1604         }
1605         if (name != NULL) {
1606                 stream->readback(name, __size_name);
1607                 if (useChecksum) checksumCalculator->addBuffer(name, __size_name);
1608         }
1609         if (useChecksum) {
1610                 unsigned char *checksumBufPtr = NULL;
1611                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1612                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1613                 stream->readback(checksumBufPtr, checksumSize);
1614                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1615                         ALOGE("glGetActiveAttrib: GL communication error, please report this issue to b.android.com.\n");
1616                         abort();
1617                 }
1618         }
1619 }
1620
1621 void glGetActiveUniform_enc(void *self , GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
1622 {
1623
1624         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1625         IOStream *stream = ctx->m_stream;
1626         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1627         bool useChecksum = checksumCalculator->getVersion() > 0;
1628
1629         const unsigned int __size_length = ((length != NULL) ?  (sizeof(GLsizei)) : 0);
1630         const unsigned int __size_size = ((size != NULL) ?  (sizeof(GLint)) : 0);
1631         const unsigned int __size_type = ((type != NULL) ?  (sizeof(GLenum)) : 0);
1632         const unsigned int __size_name = ((name != NULL) ?  bufsize : 0);
1633          unsigned char *ptr;
1634          unsigned char *buf;
1635          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 0 + 0 + 0 + 0 + 4*4;
1636          const size_t checksumSize = checksumCalculator->checksumByteSize();
1637          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1638         buf = stream->alloc(totalSize);
1639         ptr = buf;
1640         int tmp = OP_glGetActiveUniform;memcpy(ptr, &tmp, 4); ptr += 4;
1641         memcpy(ptr, &totalSize, 4);  ptr += 4;
1642
1643                 memcpy(ptr, &program, 4); ptr += 4;
1644                 memcpy(ptr, &index, 4); ptr += 4;
1645                 memcpy(ptr, &bufsize, 4); ptr += 4;
1646         *(unsigned int *)(ptr) = __size_length; ptr += 4;
1647         *(unsigned int *)(ptr) = __size_size; ptr += 4;
1648         *(unsigned int *)(ptr) = __size_type; ptr += 4;
1649         *(unsigned int *)(ptr) = __size_name; ptr += 4;
1650
1651         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1652         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1653
1654         if (length != NULL) {
1655                 stream->readback(length, __size_length);
1656                 if (useChecksum) checksumCalculator->addBuffer(length, __size_length);
1657         }
1658         if (size != NULL) {
1659                 stream->readback(size, __size_size);
1660                 if (useChecksum) checksumCalculator->addBuffer(size, __size_size);
1661         }
1662         if (type != NULL) {
1663                 stream->readback(type, __size_type);
1664                 if (useChecksum) checksumCalculator->addBuffer(type, __size_type);
1665         }
1666         if (name != NULL) {
1667                 stream->readback(name, __size_name);
1668                 if (useChecksum) checksumCalculator->addBuffer(name, __size_name);
1669         }
1670         if (useChecksum) {
1671                 unsigned char *checksumBufPtr = NULL;
1672                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1673                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1674                 stream->readback(checksumBufPtr, checksumSize);
1675                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1676                         ALOGE("glGetActiveUniform: GL communication error, please report this issue to b.android.com.\n");
1677                         abort();
1678                 }
1679         }
1680 }
1681
1682 void glGetAttachedShaders_enc(void *self , GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
1683 {
1684
1685         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1686         IOStream *stream = ctx->m_stream;
1687         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1688         bool useChecksum = checksumCalculator->getVersion() > 0;
1689
1690         const unsigned int __size_count = ((count != NULL) ?  (sizeof(GLsizei)) : 0);
1691         const unsigned int __size_shaders =  (maxcount*sizeof(GLuint));
1692          unsigned char *ptr;
1693          unsigned char *buf;
1694          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 0 + 2*4;
1695          const size_t checksumSize = checksumCalculator->checksumByteSize();
1696          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1697         buf = stream->alloc(totalSize);
1698         ptr = buf;
1699         int tmp = OP_glGetAttachedShaders;memcpy(ptr, &tmp, 4); ptr += 4;
1700         memcpy(ptr, &totalSize, 4);  ptr += 4;
1701
1702                 memcpy(ptr, &program, 4); ptr += 4;
1703                 memcpy(ptr, &maxcount, 4); ptr += 4;
1704         *(unsigned int *)(ptr) = __size_count; ptr += 4;
1705         *(unsigned int *)(ptr) = __size_shaders; ptr += 4;
1706
1707         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1708         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1709
1710         if (count != NULL) {
1711                 stream->readback(count, __size_count);
1712                 if (useChecksum) checksumCalculator->addBuffer(count, __size_count);
1713         }
1714         stream->readback(shaders, __size_shaders);
1715         if (useChecksum) checksumCalculator->addBuffer(shaders, __size_shaders);
1716         if (useChecksum) {
1717                 unsigned char *checksumBufPtr = NULL;
1718                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1719                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1720                 stream->readback(checksumBufPtr, checksumSize);
1721                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1722                         ALOGE("glGetAttachedShaders: GL communication error, please report this issue to b.android.com.\n");
1723                         abort();
1724                 }
1725         }
1726 }
1727
1728 int glGetAttribLocation_enc(void *self , GLuint program, const GLchar* name)
1729 {
1730
1731         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1732         IOStream *stream = ctx->m_stream;
1733         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1734         bool useChecksum = checksumCalculator->getVersion() > 0;
1735
1736         const unsigned int __size_name =  (strlen(name) + 1);
1737          unsigned char *ptr;
1738          unsigned char *buf;
1739          const size_t sizeWithoutChecksum = 8 + 4 + __size_name + 1*4;
1740          const size_t checksumSize = checksumCalculator->checksumByteSize();
1741          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1742         buf = stream->alloc(totalSize);
1743         ptr = buf;
1744         int tmp = OP_glGetAttribLocation;memcpy(ptr, &tmp, 4); ptr += 4;
1745         memcpy(ptr, &totalSize, 4);  ptr += 4;
1746
1747                 memcpy(ptr, &program, 4); ptr += 4;
1748         *(unsigned int *)(ptr) = __size_name; ptr += 4;
1749         memcpy(ptr, name, __size_name);ptr += __size_name;
1750
1751         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1752         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1753
1754
1755         int retval;
1756         stream->readback(&retval, 4);
1757         if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1758         if (useChecksum) {
1759                 unsigned char *checksumBufPtr = NULL;
1760                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1761                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1762                 stream->readback(checksumBufPtr, checksumSize);
1763                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1764                         ALOGE("glGetAttribLocation: GL communication error, please report this issue to b.android.com.\n");
1765                         abort();
1766                 }
1767         }
1768         return retval;
1769 }
1770
1771 void glGetBooleanv_enc(void *self , GLenum pname, GLboolean* params)
1772 {
1773
1774         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1775         IOStream *stream = ctx->m_stream;
1776         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1777         bool useChecksum = checksumCalculator->getVersion() > 0;
1778
1779         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLboolean));
1780          unsigned char *ptr;
1781          unsigned char *buf;
1782          const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
1783          const size_t checksumSize = checksumCalculator->checksumByteSize();
1784          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1785         buf = stream->alloc(totalSize);
1786         ptr = buf;
1787         int tmp = OP_glGetBooleanv;memcpy(ptr, &tmp, 4); ptr += 4;
1788         memcpy(ptr, &totalSize, 4);  ptr += 4;
1789
1790                 memcpy(ptr, &pname, 4); ptr += 4;
1791         *(unsigned int *)(ptr) = __size_params; ptr += 4;
1792
1793         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1794         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1795
1796         stream->readback(params, __size_params);
1797         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
1798         if (useChecksum) {
1799                 unsigned char *checksumBufPtr = NULL;
1800                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1801                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1802                 stream->readback(checksumBufPtr, checksumSize);
1803                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1804                         ALOGE("glGetBooleanv: GL communication error, please report this issue to b.android.com.\n");
1805                         abort();
1806                 }
1807         }
1808 }
1809
1810 void glGetBufferParameteriv_enc(void *self , GLenum target, GLenum pname, GLint* params)
1811 {
1812
1813         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1814         IOStream *stream = ctx->m_stream;
1815         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1816         bool useChecksum = checksumCalculator->getVersion() > 0;
1817
1818         const unsigned int __size_params =  (sizeof(GLint));
1819          unsigned char *ptr;
1820          unsigned char *buf;
1821          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
1822          const size_t checksumSize = checksumCalculator->checksumByteSize();
1823          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1824         buf = stream->alloc(totalSize);
1825         ptr = buf;
1826         int tmp = OP_glGetBufferParameteriv;memcpy(ptr, &tmp, 4); ptr += 4;
1827         memcpy(ptr, &totalSize, 4);  ptr += 4;
1828
1829                 memcpy(ptr, &target, 4); ptr += 4;
1830                 memcpy(ptr, &pname, 4); ptr += 4;
1831         *(unsigned int *)(ptr) = __size_params; ptr += 4;
1832
1833         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1834         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1835
1836         stream->readback(params, __size_params);
1837         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
1838         if (useChecksum) {
1839                 unsigned char *checksumBufPtr = NULL;
1840                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1841                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1842                 stream->readback(checksumBufPtr, checksumSize);
1843                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1844                         ALOGE("glGetBufferParameteriv: GL communication error, please report this issue to b.android.com.\n");
1845                         abort();
1846                 }
1847         }
1848 }
1849
1850 GLenum glGetError_enc(void *self )
1851 {
1852
1853         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1854         IOStream *stream = ctx->m_stream;
1855         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1856         bool useChecksum = checksumCalculator->getVersion() > 0;
1857
1858          unsigned char *ptr;
1859          unsigned char *buf;
1860          const size_t sizeWithoutChecksum = 8;
1861          const size_t checksumSize = checksumCalculator->checksumByteSize();
1862          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1863         buf = stream->alloc(totalSize);
1864         ptr = buf;
1865         int tmp = OP_glGetError;memcpy(ptr, &tmp, 4); ptr += 4;
1866         memcpy(ptr, &totalSize, 4);  ptr += 4;
1867
1868
1869         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1870         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1871
1872
1873         GLenum retval;
1874         stream->readback(&retval, 4);
1875         if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
1876         if (useChecksum) {
1877                 unsigned char *checksumBufPtr = NULL;
1878                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1879                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1880                 stream->readback(checksumBufPtr, checksumSize);
1881                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1882                         ALOGE("glGetError: GL communication error, please report this issue to b.android.com.\n");
1883                         abort();
1884                 }
1885         }
1886         return retval;
1887 }
1888
1889 void glGetFloatv_enc(void *self , GLenum pname, GLfloat* params)
1890 {
1891
1892         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1893         IOStream *stream = ctx->m_stream;
1894         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1895         bool useChecksum = checksumCalculator->getVersion() > 0;
1896
1897         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
1898          unsigned char *ptr;
1899          unsigned char *buf;
1900          const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
1901          const size_t checksumSize = checksumCalculator->checksumByteSize();
1902          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1903         buf = stream->alloc(totalSize);
1904         ptr = buf;
1905         int tmp = OP_glGetFloatv;memcpy(ptr, &tmp, 4); ptr += 4;
1906         memcpy(ptr, &totalSize, 4);  ptr += 4;
1907
1908                 memcpy(ptr, &pname, 4); ptr += 4;
1909         *(unsigned int *)(ptr) = __size_params; ptr += 4;
1910
1911         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1912         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1913
1914         stream->readback(params, __size_params);
1915         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
1916         if (useChecksum) {
1917                 unsigned char *checksumBufPtr = NULL;
1918                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1919                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1920                 stream->readback(checksumBufPtr, checksumSize);
1921                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1922                         ALOGE("glGetFloatv: GL communication error, please report this issue to b.android.com.\n");
1923                         abort();
1924                 }
1925         }
1926 }
1927
1928 void glGetFramebufferAttachmentParameteriv_enc(void *self , GLenum target, GLenum attachment, GLenum pname, GLint* params)
1929 {
1930
1931         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1932         IOStream *stream = ctx->m_stream;
1933         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1934         bool useChecksum = checksumCalculator->getVersion() > 0;
1935
1936         const unsigned int __size_params =  (sizeof(GLint));
1937          unsigned char *ptr;
1938          unsigned char *buf;
1939          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 0 + 1*4;
1940          const size_t checksumSize = checksumCalculator->checksumByteSize();
1941          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1942         buf = stream->alloc(totalSize);
1943         ptr = buf;
1944         int tmp = OP_glGetFramebufferAttachmentParameteriv;memcpy(ptr, &tmp, 4); ptr += 4;
1945         memcpy(ptr, &totalSize, 4);  ptr += 4;
1946
1947                 memcpy(ptr, &target, 4); ptr += 4;
1948                 memcpy(ptr, &attachment, 4); ptr += 4;
1949                 memcpy(ptr, &pname, 4); ptr += 4;
1950         *(unsigned int *)(ptr) = __size_params; ptr += 4;
1951
1952         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1953         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1954
1955         stream->readback(params, __size_params);
1956         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
1957         if (useChecksum) {
1958                 unsigned char *checksumBufPtr = NULL;
1959                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1960                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
1961                 stream->readback(checksumBufPtr, checksumSize);
1962                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
1963                         ALOGE("glGetFramebufferAttachmentParameteriv: GL communication error, please report this issue to b.android.com.\n");
1964                         abort();
1965                 }
1966         }
1967 }
1968
1969 void glGetIntegerv_enc(void *self , GLenum pname, GLint* params)
1970 {
1971
1972         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
1973         IOStream *stream = ctx->m_stream;
1974         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1975         bool useChecksum = checksumCalculator->getVersion() > 0;
1976
1977         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
1978          unsigned char *ptr;
1979          unsigned char *buf;
1980          const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
1981          const size_t checksumSize = checksumCalculator->checksumByteSize();
1982          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1983         buf = stream->alloc(totalSize);
1984         ptr = buf;
1985         int tmp = OP_glGetIntegerv;memcpy(ptr, &tmp, 4); ptr += 4;
1986         memcpy(ptr, &totalSize, 4);  ptr += 4;
1987
1988                 memcpy(ptr, &pname, 4); ptr += 4;
1989         *(unsigned int *)(ptr) = __size_params; ptr += 4;
1990
1991         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1992         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1993
1994         stream->readback(params, __size_params);
1995         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
1996         if (useChecksum) {
1997                 unsigned char *checksumBufPtr = NULL;
1998                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
1999                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2000                 stream->readback(checksumBufPtr, checksumSize);
2001                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2002                         ALOGE("glGetIntegerv: GL communication error, please report this issue to b.android.com.\n");
2003                         abort();
2004                 }
2005         }
2006 }
2007
2008 void glGetProgramiv_enc(void *self , GLuint program, GLenum pname, GLint* params)
2009 {
2010
2011         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2012         IOStream *stream = ctx->m_stream;
2013         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2014         bool useChecksum = checksumCalculator->getVersion() > 0;
2015
2016         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
2017          unsigned char *ptr;
2018          unsigned char *buf;
2019          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
2020          const size_t checksumSize = checksumCalculator->checksumByteSize();
2021          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2022         buf = stream->alloc(totalSize);
2023         ptr = buf;
2024         int tmp = OP_glGetProgramiv;memcpy(ptr, &tmp, 4); ptr += 4;
2025         memcpy(ptr, &totalSize, 4);  ptr += 4;
2026
2027                 memcpy(ptr, &program, 4); ptr += 4;
2028                 memcpy(ptr, &pname, 4); ptr += 4;
2029         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2030
2031         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2032         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2033
2034         stream->readback(params, __size_params);
2035         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
2036         if (useChecksum) {
2037                 unsigned char *checksumBufPtr = NULL;
2038                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2039                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2040                 stream->readback(checksumBufPtr, checksumSize);
2041                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2042                         ALOGE("glGetProgramiv: GL communication error, please report this issue to b.android.com.\n");
2043                         abort();
2044                 }
2045         }
2046 }
2047
2048 void glGetProgramInfoLog_enc(void *self , GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog)
2049 {
2050
2051         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2052         IOStream *stream = ctx->m_stream;
2053         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2054         bool useChecksum = checksumCalculator->getVersion() > 0;
2055
2056         const unsigned int __size_length = ((length != NULL) ?  sizeof(GLsizei) : 0);
2057         const unsigned int __size_infolog =  bufsize;
2058          unsigned char *ptr;
2059          unsigned char *buf;
2060          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 0 + 2*4;
2061          const size_t checksumSize = checksumCalculator->checksumByteSize();
2062          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2063         buf = stream->alloc(totalSize);
2064         ptr = buf;
2065         int tmp = OP_glGetProgramInfoLog;memcpy(ptr, &tmp, 4); ptr += 4;
2066         memcpy(ptr, &totalSize, 4);  ptr += 4;
2067
2068                 memcpy(ptr, &program, 4); ptr += 4;
2069                 memcpy(ptr, &bufsize, 4); ptr += 4;
2070         *(unsigned int *)(ptr) = __size_length; ptr += 4;
2071         *(unsigned int *)(ptr) = __size_infolog; ptr += 4;
2072
2073         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2074         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2075
2076         if (length != NULL) {
2077                 stream->readback(length, __size_length);
2078                 if (useChecksum) checksumCalculator->addBuffer(length, __size_length);
2079         }
2080         stream->readback(infolog, __size_infolog);
2081         if (useChecksum) checksumCalculator->addBuffer(infolog, __size_infolog);
2082         if (useChecksum) {
2083                 unsigned char *checksumBufPtr = NULL;
2084                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2085                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2086                 stream->readback(checksumBufPtr, checksumSize);
2087                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2088                         ALOGE("glGetProgramInfoLog: GL communication error, please report this issue to b.android.com.\n");
2089                         abort();
2090                 }
2091         }
2092 }
2093
2094 void glGetRenderbufferParameteriv_enc(void *self , GLenum target, GLenum pname, GLint* params)
2095 {
2096
2097         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2098         IOStream *stream = ctx->m_stream;
2099         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2100         bool useChecksum = checksumCalculator->getVersion() > 0;
2101
2102         const unsigned int __size_params =  sizeof(GLint);
2103          unsigned char *ptr;
2104          unsigned char *buf;
2105          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
2106          const size_t checksumSize = checksumCalculator->checksumByteSize();
2107          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2108         buf = stream->alloc(totalSize);
2109         ptr = buf;
2110         int tmp = OP_glGetRenderbufferParameteriv;memcpy(ptr, &tmp, 4); ptr += 4;
2111         memcpy(ptr, &totalSize, 4);  ptr += 4;
2112
2113                 memcpy(ptr, &target, 4); ptr += 4;
2114                 memcpy(ptr, &pname, 4); ptr += 4;
2115         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2116
2117         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2118         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2119
2120         stream->readback(params, __size_params);
2121         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
2122         if (useChecksum) {
2123                 unsigned char *checksumBufPtr = NULL;
2124                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2125                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2126                 stream->readback(checksumBufPtr, checksumSize);
2127                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2128                         ALOGE("glGetRenderbufferParameteriv: GL communication error, please report this issue to b.android.com.\n");
2129                         abort();
2130                 }
2131         }
2132 }
2133
2134 void glGetShaderiv_enc(void *self , GLuint shader, GLenum pname, GLint* params)
2135 {
2136
2137         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2138         IOStream *stream = ctx->m_stream;
2139         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2140         bool useChecksum = checksumCalculator->getVersion() > 0;
2141
2142         const unsigned int __size_params =  sizeof(GLint);
2143          unsigned char *ptr;
2144          unsigned char *buf;
2145          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
2146          const size_t checksumSize = checksumCalculator->checksumByteSize();
2147          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2148         buf = stream->alloc(totalSize);
2149         ptr = buf;
2150         int tmp = OP_glGetShaderiv;memcpy(ptr, &tmp, 4); ptr += 4;
2151         memcpy(ptr, &totalSize, 4);  ptr += 4;
2152
2153                 memcpy(ptr, &shader, 4); ptr += 4;
2154                 memcpy(ptr, &pname, 4); ptr += 4;
2155         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2156
2157         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2158         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2159
2160         stream->readback(params, __size_params);
2161         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
2162         if (useChecksum) {
2163                 unsigned char *checksumBufPtr = NULL;
2164                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2165                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2166                 stream->readback(checksumBufPtr, checksumSize);
2167                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2168                         ALOGE("glGetShaderiv: GL communication error, please report this issue to b.android.com.\n");
2169                         abort();
2170                 }
2171         }
2172 }
2173
2174 void glGetShaderInfoLog_enc(void *self , GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog)
2175 {
2176
2177         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2178         IOStream *stream = ctx->m_stream;
2179         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2180         bool useChecksum = checksumCalculator->getVersion() > 0;
2181
2182         const unsigned int __size_length = ((length != NULL) ?  (sizeof(GLsizei)) : 0);
2183         const unsigned int __size_infolog =  bufsize;
2184          unsigned char *ptr;
2185          unsigned char *buf;
2186          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 0 + 2*4;
2187          const size_t checksumSize = checksumCalculator->checksumByteSize();
2188          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2189         buf = stream->alloc(totalSize);
2190         ptr = buf;
2191         int tmp = OP_glGetShaderInfoLog;memcpy(ptr, &tmp, 4); ptr += 4;
2192         memcpy(ptr, &totalSize, 4);  ptr += 4;
2193
2194                 memcpy(ptr, &shader, 4); ptr += 4;
2195                 memcpy(ptr, &bufsize, 4); ptr += 4;
2196         *(unsigned int *)(ptr) = __size_length; ptr += 4;
2197         *(unsigned int *)(ptr) = __size_infolog; ptr += 4;
2198
2199         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2200         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2201
2202         if (length != NULL) {
2203                 stream->readback(length, __size_length);
2204                 if (useChecksum) checksumCalculator->addBuffer(length, __size_length);
2205         }
2206         stream->readback(infolog, __size_infolog);
2207         if (useChecksum) checksumCalculator->addBuffer(infolog, __size_infolog);
2208         if (useChecksum) {
2209                 unsigned char *checksumBufPtr = NULL;
2210                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2211                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2212                 stream->readback(checksumBufPtr, checksumSize);
2213                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2214                         ALOGE("glGetShaderInfoLog: GL communication error, please report this issue to b.android.com.\n");
2215                         abort();
2216                 }
2217         }
2218 }
2219
2220 void glGetShaderPrecisionFormat_enc(void *self , GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
2221 {
2222
2223         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2224         IOStream *stream = ctx->m_stream;
2225         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2226         bool useChecksum = checksumCalculator->getVersion() > 0;
2227
2228         const unsigned int __size_range =  (2 * sizeof(GLint));
2229         const unsigned int __size_precision =  (sizeof(GLint));
2230          unsigned char *ptr;
2231          unsigned char *buf;
2232          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 0 + 2*4;
2233          const size_t checksumSize = checksumCalculator->checksumByteSize();
2234          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2235         buf = stream->alloc(totalSize);
2236         ptr = buf;
2237         int tmp = OP_glGetShaderPrecisionFormat;memcpy(ptr, &tmp, 4); ptr += 4;
2238         memcpy(ptr, &totalSize, 4);  ptr += 4;
2239
2240                 memcpy(ptr, &shadertype, 4); ptr += 4;
2241                 memcpy(ptr, &precisiontype, 4); ptr += 4;
2242         *(unsigned int *)(ptr) = __size_range; ptr += 4;
2243         *(unsigned int *)(ptr) = __size_precision; ptr += 4;
2244
2245         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2246         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2247
2248         stream->readback(range, __size_range);
2249         if (useChecksum) checksumCalculator->addBuffer(range, __size_range);
2250         stream->readback(precision, __size_precision);
2251         if (useChecksum) checksumCalculator->addBuffer(precision, __size_precision);
2252         if (useChecksum) {
2253                 unsigned char *checksumBufPtr = NULL;
2254                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2255                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2256                 stream->readback(checksumBufPtr, checksumSize);
2257                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2258                         ALOGE("glGetShaderPrecisionFormat: GL communication error, please report this issue to b.android.com.\n");
2259                         abort();
2260                 }
2261         }
2262 }
2263
2264 void glGetShaderSource_enc(void *self , GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source)
2265 {
2266
2267         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2268         IOStream *stream = ctx->m_stream;
2269         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2270         bool useChecksum = checksumCalculator->getVersion() > 0;
2271
2272         const unsigned int __size_length = ((length != NULL) ?  (sizeof(GLsizei)) : 0);
2273         const unsigned int __size_source =  bufsize;
2274          unsigned char *ptr;
2275          unsigned char *buf;
2276          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 0 + 2*4;
2277          const size_t checksumSize = checksumCalculator->checksumByteSize();
2278          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2279         buf = stream->alloc(totalSize);
2280         ptr = buf;
2281         int tmp = OP_glGetShaderSource;memcpy(ptr, &tmp, 4); ptr += 4;
2282         memcpy(ptr, &totalSize, 4);  ptr += 4;
2283
2284                 memcpy(ptr, &shader, 4); ptr += 4;
2285                 memcpy(ptr, &bufsize, 4); ptr += 4;
2286         *(unsigned int *)(ptr) = __size_length; ptr += 4;
2287         *(unsigned int *)(ptr) = __size_source; ptr += 4;
2288
2289         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2290         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2291
2292         if (length != NULL) {
2293                 stream->readback(length, __size_length);
2294                 if (useChecksum) checksumCalculator->addBuffer(length, __size_length);
2295         }
2296         stream->readback(source, __size_source);
2297         if (useChecksum) checksumCalculator->addBuffer(source, __size_source);
2298         if (useChecksum) {
2299                 unsigned char *checksumBufPtr = NULL;
2300                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2301                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2302                 stream->readback(checksumBufPtr, checksumSize);
2303                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2304                         ALOGE("glGetShaderSource: GL communication error, please report this issue to b.android.com.\n");
2305                         abort();
2306                 }
2307         }
2308 }
2309
2310 void glGetTexParameterfv_enc(void *self , GLenum target, GLenum pname, GLfloat* params)
2311 {
2312
2313         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2314         IOStream *stream = ctx->m_stream;
2315         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2316         bool useChecksum = checksumCalculator->getVersion() > 0;
2317
2318         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
2319          unsigned char *ptr;
2320          unsigned char *buf;
2321          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
2322          const size_t checksumSize = checksumCalculator->checksumByteSize();
2323          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2324         buf = stream->alloc(totalSize);
2325         ptr = buf;
2326         int tmp = OP_glGetTexParameterfv;memcpy(ptr, &tmp, 4); ptr += 4;
2327         memcpy(ptr, &totalSize, 4);  ptr += 4;
2328
2329                 memcpy(ptr, &target, 4); ptr += 4;
2330                 memcpy(ptr, &pname, 4); ptr += 4;
2331         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2332
2333         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2334         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2335
2336         stream->readback(params, __size_params);
2337         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
2338         if (useChecksum) {
2339                 unsigned char *checksumBufPtr = NULL;
2340                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2341                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2342                 stream->readback(checksumBufPtr, checksumSize);
2343                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2344                         ALOGE("glGetTexParameterfv: GL communication error, please report this issue to b.android.com.\n");
2345                         abort();
2346                 }
2347         }
2348 }
2349
2350 void glGetTexParameteriv_enc(void *self , GLenum target, GLenum pname, GLint* params)
2351 {
2352
2353         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2354         IOStream *stream = ctx->m_stream;
2355         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2356         bool useChecksum = checksumCalculator->getVersion() > 0;
2357
2358         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
2359          unsigned char *ptr;
2360          unsigned char *buf;
2361          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
2362          const size_t checksumSize = checksumCalculator->checksumByteSize();
2363          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2364         buf = stream->alloc(totalSize);
2365         ptr = buf;
2366         int tmp = OP_glGetTexParameteriv;memcpy(ptr, &tmp, 4); ptr += 4;
2367         memcpy(ptr, &totalSize, 4);  ptr += 4;
2368
2369                 memcpy(ptr, &target, 4); ptr += 4;
2370                 memcpy(ptr, &pname, 4); ptr += 4;
2371         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2372
2373         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2374         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2375
2376         stream->readback(params, __size_params);
2377         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
2378         if (useChecksum) {
2379                 unsigned char *checksumBufPtr = NULL;
2380                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2381                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2382                 stream->readback(checksumBufPtr, checksumSize);
2383                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2384                         ALOGE("glGetTexParameteriv: GL communication error, please report this issue to b.android.com.\n");
2385                         abort();
2386                 }
2387         }
2388 }
2389
2390 void glGetUniformfv_enc(void *self , GLuint program, GLint location, GLfloat* params)
2391 {
2392
2393         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2394         IOStream *stream = ctx->m_stream;
2395         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2396         bool useChecksum = checksumCalculator->getVersion() > 0;
2397
2398         const unsigned int __size_params =  glSizeof(glesv2_enc::uniformType(self, program, location));
2399          unsigned char *ptr;
2400          unsigned char *buf;
2401          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
2402          const size_t checksumSize = checksumCalculator->checksumByteSize();
2403          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2404         buf = stream->alloc(totalSize);
2405         ptr = buf;
2406         int tmp = OP_glGetUniformfv;memcpy(ptr, &tmp, 4); ptr += 4;
2407         memcpy(ptr, &totalSize, 4);  ptr += 4;
2408
2409                 memcpy(ptr, &program, 4); ptr += 4;
2410                 memcpy(ptr, &location, 4); ptr += 4;
2411         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2412
2413         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2414         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2415
2416         stream->readback(params, __size_params);
2417         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
2418         if (useChecksum) {
2419                 unsigned char *checksumBufPtr = NULL;
2420                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2421                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2422                 stream->readback(checksumBufPtr, checksumSize);
2423                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2424                         ALOGE("glGetUniformfv: GL communication error, please report this issue to b.android.com.\n");
2425                         abort();
2426                 }
2427         }
2428 }
2429
2430 void glGetUniformiv_enc(void *self , GLuint program, GLint location, GLint* params)
2431 {
2432
2433         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2434         IOStream *stream = ctx->m_stream;
2435         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2436         bool useChecksum = checksumCalculator->getVersion() > 0;
2437
2438         const unsigned int __size_params =  glSizeof(glesv2_enc::uniformType(self, program, location));
2439          unsigned char *ptr;
2440          unsigned char *buf;
2441          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
2442          const size_t checksumSize = checksumCalculator->checksumByteSize();
2443          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2444         buf = stream->alloc(totalSize);
2445         ptr = buf;
2446         int tmp = OP_glGetUniformiv;memcpy(ptr, &tmp, 4); ptr += 4;
2447         memcpy(ptr, &totalSize, 4);  ptr += 4;
2448
2449                 memcpy(ptr, &program, 4); ptr += 4;
2450                 memcpy(ptr, &location, 4); ptr += 4;
2451         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2452
2453         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2454         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2455
2456         stream->readback(params, __size_params);
2457         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
2458         if (useChecksum) {
2459                 unsigned char *checksumBufPtr = NULL;
2460                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2461                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2462                 stream->readback(checksumBufPtr, checksumSize);
2463                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2464                         ALOGE("glGetUniformiv: GL communication error, please report this issue to b.android.com.\n");
2465                         abort();
2466                 }
2467         }
2468 }
2469
2470 int glGetUniformLocation_enc(void *self , GLuint program, const GLchar* name)
2471 {
2472
2473         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2474         IOStream *stream = ctx->m_stream;
2475         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2476         bool useChecksum = checksumCalculator->getVersion() > 0;
2477
2478         const unsigned int __size_name =  (strlen(name) + 1);
2479          unsigned char *ptr;
2480          unsigned char *buf;
2481          const size_t sizeWithoutChecksum = 8 + 4 + __size_name + 1*4;
2482          const size_t checksumSize = checksumCalculator->checksumByteSize();
2483          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2484         buf = stream->alloc(totalSize);
2485         ptr = buf;
2486         int tmp = OP_glGetUniformLocation;memcpy(ptr, &tmp, 4); ptr += 4;
2487         memcpy(ptr, &totalSize, 4);  ptr += 4;
2488
2489                 memcpy(ptr, &program, 4); ptr += 4;
2490         *(unsigned int *)(ptr) = __size_name; ptr += 4;
2491         memcpy(ptr, name, __size_name);ptr += __size_name;
2492
2493         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2494         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2495
2496
2497         int retval;
2498         stream->readback(&retval, 4);
2499         if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2500         if (useChecksum) {
2501                 unsigned char *checksumBufPtr = NULL;
2502                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2503                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2504                 stream->readback(checksumBufPtr, checksumSize);
2505                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2506                         ALOGE("glGetUniformLocation: GL communication error, please report this issue to b.android.com.\n");
2507                         abort();
2508                 }
2509         }
2510         return retval;
2511 }
2512
2513 void glGetVertexAttribfv_enc(void *self , GLuint index, GLenum pname, GLfloat* params)
2514 {
2515
2516         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2517         IOStream *stream = ctx->m_stream;
2518         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2519         bool useChecksum = checksumCalculator->getVersion() > 0;
2520
2521         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
2522          unsigned char *ptr;
2523          unsigned char *buf;
2524          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
2525          const size_t checksumSize = checksumCalculator->checksumByteSize();
2526          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2527         buf = stream->alloc(totalSize);
2528         ptr = buf;
2529         int tmp = OP_glGetVertexAttribfv;memcpy(ptr, &tmp, 4); ptr += 4;
2530         memcpy(ptr, &totalSize, 4);  ptr += 4;
2531
2532                 memcpy(ptr, &index, 4); ptr += 4;
2533                 memcpy(ptr, &pname, 4); ptr += 4;
2534         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2535
2536         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2537         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2538
2539         stream->readback(params, __size_params);
2540         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
2541         if (useChecksum) {
2542                 unsigned char *checksumBufPtr = NULL;
2543                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2544                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2545                 stream->readback(checksumBufPtr, checksumSize);
2546                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2547                         ALOGE("glGetVertexAttribfv: GL communication error, please report this issue to b.android.com.\n");
2548                         abort();
2549                 }
2550         }
2551 }
2552
2553 void glGetVertexAttribiv_enc(void *self , GLuint index, GLenum pname, GLint* params)
2554 {
2555
2556         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2557         IOStream *stream = ctx->m_stream;
2558         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2559         bool useChecksum = checksumCalculator->getVersion() > 0;
2560
2561         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
2562          unsigned char *ptr;
2563          unsigned char *buf;
2564          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
2565          const size_t checksumSize = checksumCalculator->checksumByteSize();
2566          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2567         buf = stream->alloc(totalSize);
2568         ptr = buf;
2569         int tmp = OP_glGetVertexAttribiv;memcpy(ptr, &tmp, 4); ptr += 4;
2570         memcpy(ptr, &totalSize, 4);  ptr += 4;
2571
2572                 memcpy(ptr, &index, 4); ptr += 4;
2573                 memcpy(ptr, &pname, 4); ptr += 4;
2574         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2575
2576         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2577         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2578
2579         stream->readback(params, __size_params);
2580         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
2581         if (useChecksum) {
2582                 unsigned char *checksumBufPtr = NULL;
2583                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2584                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2585                 stream->readback(checksumBufPtr, checksumSize);
2586                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2587                         ALOGE("glGetVertexAttribiv: GL communication error, please report this issue to b.android.com.\n");
2588                         abort();
2589                 }
2590         }
2591 }
2592
2593 void glHint_enc(void *self , GLenum target, GLenum mode)
2594 {
2595
2596         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2597         IOStream *stream = ctx->m_stream;
2598         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2599         bool useChecksum = checksumCalculator->getVersion() > 0;
2600
2601          unsigned char *ptr;
2602          unsigned char *buf;
2603          const size_t sizeWithoutChecksum = 8 + 4 + 4;
2604          const size_t checksumSize = checksumCalculator->checksumByteSize();
2605          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2606         buf = stream->alloc(totalSize);
2607         ptr = buf;
2608         int tmp = OP_glHint;memcpy(ptr, &tmp, 4); ptr += 4;
2609         memcpy(ptr, &totalSize, 4);  ptr += 4;
2610
2611                 memcpy(ptr, &target, 4); ptr += 4;
2612                 memcpy(ptr, &mode, 4); ptr += 4;
2613
2614         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2615         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2616
2617 }
2618
2619 GLboolean glIsBuffer_enc(void *self , GLuint buffer)
2620 {
2621
2622         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2623         IOStream *stream = ctx->m_stream;
2624         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2625         bool useChecksum = checksumCalculator->getVersion() > 0;
2626
2627          unsigned char *ptr;
2628          unsigned char *buf;
2629          const size_t sizeWithoutChecksum = 8 + 4;
2630          const size_t checksumSize = checksumCalculator->checksumByteSize();
2631          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2632         buf = stream->alloc(totalSize);
2633         ptr = buf;
2634         int tmp = OP_glIsBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
2635         memcpy(ptr, &totalSize, 4);  ptr += 4;
2636
2637                 memcpy(ptr, &buffer, 4); ptr += 4;
2638
2639         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2640         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2641
2642
2643         GLboolean retval;
2644         stream->readback(&retval, 1);
2645         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
2646         if (useChecksum) {
2647                 unsigned char *checksumBufPtr = NULL;
2648                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2649                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2650                 stream->readback(checksumBufPtr, checksumSize);
2651                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2652                         ALOGE("glIsBuffer: GL communication error, please report this issue to b.android.com.\n");
2653                         abort();
2654                 }
2655         }
2656         return retval;
2657 }
2658
2659 GLboolean glIsEnabled_enc(void *self , GLenum cap)
2660 {
2661
2662         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2663         IOStream *stream = ctx->m_stream;
2664         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2665         bool useChecksum = checksumCalculator->getVersion() > 0;
2666
2667          unsigned char *ptr;
2668          unsigned char *buf;
2669          const size_t sizeWithoutChecksum = 8 + 4;
2670          const size_t checksumSize = checksumCalculator->checksumByteSize();
2671          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2672         buf = stream->alloc(totalSize);
2673         ptr = buf;
2674         int tmp = OP_glIsEnabled;memcpy(ptr, &tmp, 4); ptr += 4;
2675         memcpy(ptr, &totalSize, 4);  ptr += 4;
2676
2677                 memcpy(ptr, &cap, 4); ptr += 4;
2678
2679         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2680         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2681
2682
2683         GLboolean retval;
2684         stream->readback(&retval, 1);
2685         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
2686         if (useChecksum) {
2687                 unsigned char *checksumBufPtr = NULL;
2688                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2689                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2690                 stream->readback(checksumBufPtr, checksumSize);
2691                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2692                         ALOGE("glIsEnabled: GL communication error, please report this issue to b.android.com.\n");
2693                         abort();
2694                 }
2695         }
2696         return retval;
2697 }
2698
2699 GLboolean glIsFramebuffer_enc(void *self , GLuint framebuffer)
2700 {
2701
2702         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2703         IOStream *stream = ctx->m_stream;
2704         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2705         bool useChecksum = checksumCalculator->getVersion() > 0;
2706
2707          unsigned char *ptr;
2708          unsigned char *buf;
2709          const size_t sizeWithoutChecksum = 8 + 4;
2710          const size_t checksumSize = checksumCalculator->checksumByteSize();
2711          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2712         buf = stream->alloc(totalSize);
2713         ptr = buf;
2714         int tmp = OP_glIsFramebuffer;memcpy(ptr, &tmp, 4); ptr += 4;
2715         memcpy(ptr, &totalSize, 4);  ptr += 4;
2716
2717                 memcpy(ptr, &framebuffer, 4); ptr += 4;
2718
2719         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2720         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2721
2722
2723         GLboolean retval;
2724         stream->readback(&retval, 1);
2725         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
2726         if (useChecksum) {
2727                 unsigned char *checksumBufPtr = NULL;
2728                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2729                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2730                 stream->readback(checksumBufPtr, checksumSize);
2731                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2732                         ALOGE("glIsFramebuffer: GL communication error, please report this issue to b.android.com.\n");
2733                         abort();
2734                 }
2735         }
2736         return retval;
2737 }
2738
2739 GLboolean glIsProgram_enc(void *self , GLuint program)
2740 {
2741
2742         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2743         IOStream *stream = ctx->m_stream;
2744         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2745         bool useChecksum = checksumCalculator->getVersion() > 0;
2746
2747          unsigned char *ptr;
2748          unsigned char *buf;
2749          const size_t sizeWithoutChecksum = 8 + 4;
2750          const size_t checksumSize = checksumCalculator->checksumByteSize();
2751          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2752         buf = stream->alloc(totalSize);
2753         ptr = buf;
2754         int tmp = OP_glIsProgram;memcpy(ptr, &tmp, 4); ptr += 4;
2755         memcpy(ptr, &totalSize, 4);  ptr += 4;
2756
2757                 memcpy(ptr, &program, 4); ptr += 4;
2758
2759         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2760         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2761
2762
2763         GLboolean retval;
2764         stream->readback(&retval, 1);
2765         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
2766         if (useChecksum) {
2767                 unsigned char *checksumBufPtr = NULL;
2768                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2769                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2770                 stream->readback(checksumBufPtr, checksumSize);
2771                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2772                         ALOGE("glIsProgram: GL communication error, please report this issue to b.android.com.\n");
2773                         abort();
2774                 }
2775         }
2776         return retval;
2777 }
2778
2779 GLboolean glIsRenderbuffer_enc(void *self , GLuint renderbuffer)
2780 {
2781
2782         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2783         IOStream *stream = ctx->m_stream;
2784         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2785         bool useChecksum = checksumCalculator->getVersion() > 0;
2786
2787          unsigned char *ptr;
2788          unsigned char *buf;
2789          const size_t sizeWithoutChecksum = 8 + 4;
2790          const size_t checksumSize = checksumCalculator->checksumByteSize();
2791          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2792         buf = stream->alloc(totalSize);
2793         ptr = buf;
2794         int tmp = OP_glIsRenderbuffer;memcpy(ptr, &tmp, 4); ptr += 4;
2795         memcpy(ptr, &totalSize, 4);  ptr += 4;
2796
2797                 memcpy(ptr, &renderbuffer, 4); ptr += 4;
2798
2799         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2800         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2801
2802
2803         GLboolean retval;
2804         stream->readback(&retval, 1);
2805         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
2806         if (useChecksum) {
2807                 unsigned char *checksumBufPtr = NULL;
2808                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2809                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2810                 stream->readback(checksumBufPtr, checksumSize);
2811                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2812                         ALOGE("glIsRenderbuffer: GL communication error, please report this issue to b.android.com.\n");
2813                         abort();
2814                 }
2815         }
2816         return retval;
2817 }
2818
2819 GLboolean glIsShader_enc(void *self , GLuint shader)
2820 {
2821
2822         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2823         IOStream *stream = ctx->m_stream;
2824         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2825         bool useChecksum = checksumCalculator->getVersion() > 0;
2826
2827          unsigned char *ptr;
2828          unsigned char *buf;
2829          const size_t sizeWithoutChecksum = 8 + 4;
2830          const size_t checksumSize = checksumCalculator->checksumByteSize();
2831          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2832         buf = stream->alloc(totalSize);
2833         ptr = buf;
2834         int tmp = OP_glIsShader;memcpy(ptr, &tmp, 4); ptr += 4;
2835         memcpy(ptr, &totalSize, 4);  ptr += 4;
2836
2837                 memcpy(ptr, &shader, 4); ptr += 4;
2838
2839         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2840         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2841
2842
2843         GLboolean retval;
2844         stream->readback(&retval, 1);
2845         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
2846         if (useChecksum) {
2847                 unsigned char *checksumBufPtr = NULL;
2848                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2849                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2850                 stream->readback(checksumBufPtr, checksumSize);
2851                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2852                         ALOGE("glIsShader: GL communication error, please report this issue to b.android.com.\n");
2853                         abort();
2854                 }
2855         }
2856         return retval;
2857 }
2858
2859 GLboolean glIsTexture_enc(void *self , GLuint texture)
2860 {
2861
2862         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2863         IOStream *stream = ctx->m_stream;
2864         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2865         bool useChecksum = checksumCalculator->getVersion() > 0;
2866
2867          unsigned char *ptr;
2868          unsigned char *buf;
2869          const size_t sizeWithoutChecksum = 8 + 4;
2870          const size_t checksumSize = checksumCalculator->checksumByteSize();
2871          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2872         buf = stream->alloc(totalSize);
2873         ptr = buf;
2874         int tmp = OP_glIsTexture;memcpy(ptr, &tmp, 4); ptr += 4;
2875         memcpy(ptr, &totalSize, 4);  ptr += 4;
2876
2877                 memcpy(ptr, &texture, 4); ptr += 4;
2878
2879         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2880         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2881
2882
2883         GLboolean retval;
2884         stream->readback(&retval, 1);
2885         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
2886         if (useChecksum) {
2887                 unsigned char *checksumBufPtr = NULL;
2888                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
2889                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
2890                 stream->readback(checksumBufPtr, checksumSize);
2891                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
2892                         ALOGE("glIsTexture: GL communication error, please report this issue to b.android.com.\n");
2893                         abort();
2894                 }
2895         }
2896         return retval;
2897 }
2898
2899 void glLineWidth_enc(void *self , GLfloat width)
2900 {
2901
2902         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2903         IOStream *stream = ctx->m_stream;
2904         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2905         bool useChecksum = checksumCalculator->getVersion() > 0;
2906
2907          unsigned char *ptr;
2908          unsigned char *buf;
2909          const size_t sizeWithoutChecksum = 8 + 4;
2910          const size_t checksumSize = checksumCalculator->checksumByteSize();
2911          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2912         buf = stream->alloc(totalSize);
2913         ptr = buf;
2914         int tmp = OP_glLineWidth;memcpy(ptr, &tmp, 4); ptr += 4;
2915         memcpy(ptr, &totalSize, 4);  ptr += 4;
2916
2917                 memcpy(ptr, &width, 4); ptr += 4;
2918
2919         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2920         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2921
2922 }
2923
2924 void glLinkProgram_enc(void *self , GLuint program)
2925 {
2926
2927         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2928         IOStream *stream = ctx->m_stream;
2929         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2930         bool useChecksum = checksumCalculator->getVersion() > 0;
2931
2932          unsigned char *ptr;
2933          unsigned char *buf;
2934          const size_t sizeWithoutChecksum = 8 + 4;
2935          const size_t checksumSize = checksumCalculator->checksumByteSize();
2936          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2937         buf = stream->alloc(totalSize);
2938         ptr = buf;
2939         int tmp = OP_glLinkProgram;memcpy(ptr, &tmp, 4); ptr += 4;
2940         memcpy(ptr, &totalSize, 4);  ptr += 4;
2941
2942                 memcpy(ptr, &program, 4); ptr += 4;
2943
2944         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2945         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2946
2947 }
2948
2949 void glPixelStorei_enc(void *self , GLenum pname, GLint param)
2950 {
2951
2952         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2953         IOStream *stream = ctx->m_stream;
2954         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2955         bool useChecksum = checksumCalculator->getVersion() > 0;
2956
2957          unsigned char *ptr;
2958          unsigned char *buf;
2959          const size_t sizeWithoutChecksum = 8 + 4 + 4;
2960          const size_t checksumSize = checksumCalculator->checksumByteSize();
2961          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2962         buf = stream->alloc(totalSize);
2963         ptr = buf;
2964         int tmp = OP_glPixelStorei;memcpy(ptr, &tmp, 4); ptr += 4;
2965         memcpy(ptr, &totalSize, 4);  ptr += 4;
2966
2967                 memcpy(ptr, &pname, 4); ptr += 4;
2968                 memcpy(ptr, &param, 4); ptr += 4;
2969
2970         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2971         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2972
2973 }
2974
2975 void glPolygonOffset_enc(void *self , GLfloat factor, GLfloat units)
2976 {
2977
2978         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
2979         IOStream *stream = ctx->m_stream;
2980         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2981         bool useChecksum = checksumCalculator->getVersion() > 0;
2982
2983          unsigned char *ptr;
2984          unsigned char *buf;
2985          const size_t sizeWithoutChecksum = 8 + 4 + 4;
2986          const size_t checksumSize = checksumCalculator->checksumByteSize();
2987          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2988         buf = stream->alloc(totalSize);
2989         ptr = buf;
2990         int tmp = OP_glPolygonOffset;memcpy(ptr, &tmp, 4); ptr += 4;
2991         memcpy(ptr, &totalSize, 4);  ptr += 4;
2992
2993                 memcpy(ptr, &factor, 4); ptr += 4;
2994                 memcpy(ptr, &units, 4); ptr += 4;
2995
2996         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2997         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2998
2999 }
3000
3001 void glReadPixels_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
3002 {
3003
3004         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3005         IOStream *stream = ctx->m_stream;
3006         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3007         bool useChecksum = checksumCalculator->getVersion() > 0;
3008
3009         const unsigned int __size_pixels =  glesv2_enc::pixelDataSize(self, width, height, format, type, 1);
3010          unsigned char *ptr;
3011          unsigned char *buf;
3012          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 0 + 1*4;
3013          const size_t checksumSize = checksumCalculator->checksumByteSize();
3014          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3015         buf = stream->alloc(totalSize);
3016         ptr = buf;
3017         int tmp = OP_glReadPixels;memcpy(ptr, &tmp, 4); ptr += 4;
3018         memcpy(ptr, &totalSize, 4);  ptr += 4;
3019
3020                 memcpy(ptr, &x, 4); ptr += 4;
3021                 memcpy(ptr, &y, 4); ptr += 4;
3022                 memcpy(ptr, &width, 4); ptr += 4;
3023                 memcpy(ptr, &height, 4); ptr += 4;
3024                 memcpy(ptr, &format, 4); ptr += 4;
3025                 memcpy(ptr, &type, 4); ptr += 4;
3026         *(unsigned int *)(ptr) = __size_pixels; ptr += 4;
3027
3028         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3029         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3030
3031         stream->readback(pixels, __size_pixels);
3032         if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
3033         if (useChecksum) {
3034                 unsigned char *checksumBufPtr = NULL;
3035                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
3036                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
3037                 stream->readback(checksumBufPtr, checksumSize);
3038                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
3039                         ALOGE("glReadPixels: GL communication error, please report this issue to b.android.com.\n");
3040                         abort();
3041                 }
3042         }
3043 }
3044
3045 void glReleaseShaderCompiler_enc(void *self )
3046 {
3047
3048         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3049         IOStream *stream = ctx->m_stream;
3050         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3051         bool useChecksum = checksumCalculator->getVersion() > 0;
3052
3053          unsigned char *ptr;
3054          unsigned char *buf;
3055          const size_t sizeWithoutChecksum = 8;
3056          const size_t checksumSize = checksumCalculator->checksumByteSize();
3057          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3058         buf = stream->alloc(totalSize);
3059         ptr = buf;
3060         int tmp = OP_glReleaseShaderCompiler;memcpy(ptr, &tmp, 4); ptr += 4;
3061         memcpy(ptr, &totalSize, 4);  ptr += 4;
3062
3063
3064         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3065         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3066
3067 }
3068
3069 void glRenderbufferStorage_enc(void *self , GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
3070 {
3071
3072         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3073         IOStream *stream = ctx->m_stream;
3074         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3075         bool useChecksum = checksumCalculator->getVersion() > 0;
3076
3077          unsigned char *ptr;
3078          unsigned char *buf;
3079          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
3080          const size_t checksumSize = checksumCalculator->checksumByteSize();
3081          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3082         buf = stream->alloc(totalSize);
3083         ptr = buf;
3084         int tmp = OP_glRenderbufferStorage;memcpy(ptr, &tmp, 4); ptr += 4;
3085         memcpy(ptr, &totalSize, 4);  ptr += 4;
3086
3087                 memcpy(ptr, &target, 4); ptr += 4;
3088                 memcpy(ptr, &internalformat, 4); ptr += 4;
3089                 memcpy(ptr, &width, 4); ptr += 4;
3090                 memcpy(ptr, &height, 4); ptr += 4;
3091
3092         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3093         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3094
3095 }
3096
3097 void glSampleCoverage_enc(void *self , GLclampf value, GLboolean invert)
3098 {
3099
3100         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3101         IOStream *stream = ctx->m_stream;
3102         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3103         bool useChecksum = checksumCalculator->getVersion() > 0;
3104
3105          unsigned char *ptr;
3106          unsigned char *buf;
3107          const size_t sizeWithoutChecksum = 8 + 4 + 1;
3108          const size_t checksumSize = checksumCalculator->checksumByteSize();
3109          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3110         buf = stream->alloc(totalSize);
3111         ptr = buf;
3112         int tmp = OP_glSampleCoverage;memcpy(ptr, &tmp, 4); ptr += 4;
3113         memcpy(ptr, &totalSize, 4);  ptr += 4;
3114
3115                 memcpy(ptr, &value, 4); ptr += 4;
3116                 memcpy(ptr, &invert, 1); ptr += 1;
3117
3118         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3119         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3120
3121 }
3122
3123 void glScissor_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height)
3124 {
3125
3126         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3127         IOStream *stream = ctx->m_stream;
3128         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3129         bool useChecksum = checksumCalculator->getVersion() > 0;
3130
3131          unsigned char *ptr;
3132          unsigned char *buf;
3133          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
3134          const size_t checksumSize = checksumCalculator->checksumByteSize();
3135          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3136         buf = stream->alloc(totalSize);
3137         ptr = buf;
3138         int tmp = OP_glScissor;memcpy(ptr, &tmp, 4); ptr += 4;
3139         memcpy(ptr, &totalSize, 4);  ptr += 4;
3140
3141                 memcpy(ptr, &x, 4); ptr += 4;
3142                 memcpy(ptr, &y, 4); ptr += 4;
3143                 memcpy(ptr, &width, 4); ptr += 4;
3144                 memcpy(ptr, &height, 4); ptr += 4;
3145
3146         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3147         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3148
3149 }
3150
3151 void glStencilFunc_enc(void *self , GLenum func, GLint ref, GLuint mask)
3152 {
3153
3154         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3155         IOStream *stream = ctx->m_stream;
3156         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3157         bool useChecksum = checksumCalculator->getVersion() > 0;
3158
3159          unsigned char *ptr;
3160          unsigned char *buf;
3161          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
3162          const size_t checksumSize = checksumCalculator->checksumByteSize();
3163          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3164         buf = stream->alloc(totalSize);
3165         ptr = buf;
3166         int tmp = OP_glStencilFunc;memcpy(ptr, &tmp, 4); ptr += 4;
3167         memcpy(ptr, &totalSize, 4);  ptr += 4;
3168
3169                 memcpy(ptr, &func, 4); ptr += 4;
3170                 memcpy(ptr, &ref, 4); ptr += 4;
3171                 memcpy(ptr, &mask, 4); ptr += 4;
3172
3173         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3174         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3175
3176 }
3177
3178 void glStencilFuncSeparate_enc(void *self , GLenum face, GLenum func, GLint ref, GLuint mask)
3179 {
3180
3181         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3182         IOStream *stream = ctx->m_stream;
3183         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3184         bool useChecksum = checksumCalculator->getVersion() > 0;
3185
3186          unsigned char *ptr;
3187          unsigned char *buf;
3188          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
3189          const size_t checksumSize = checksumCalculator->checksumByteSize();
3190          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3191         buf = stream->alloc(totalSize);
3192         ptr = buf;
3193         int tmp = OP_glStencilFuncSeparate;memcpy(ptr, &tmp, 4); ptr += 4;
3194         memcpy(ptr, &totalSize, 4);  ptr += 4;
3195
3196                 memcpy(ptr, &face, 4); ptr += 4;
3197                 memcpy(ptr, &func, 4); ptr += 4;
3198                 memcpy(ptr, &ref, 4); ptr += 4;
3199                 memcpy(ptr, &mask, 4); ptr += 4;
3200
3201         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3202         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3203
3204 }
3205
3206 void glStencilMask_enc(void *self , GLuint mask)
3207 {
3208
3209         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3210         IOStream *stream = ctx->m_stream;
3211         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3212         bool useChecksum = checksumCalculator->getVersion() > 0;
3213
3214          unsigned char *ptr;
3215          unsigned char *buf;
3216          const size_t sizeWithoutChecksum = 8 + 4;
3217          const size_t checksumSize = checksumCalculator->checksumByteSize();
3218          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3219         buf = stream->alloc(totalSize);
3220         ptr = buf;
3221         int tmp = OP_glStencilMask;memcpy(ptr, &tmp, 4); ptr += 4;
3222         memcpy(ptr, &totalSize, 4);  ptr += 4;
3223
3224                 memcpy(ptr, &mask, 4); ptr += 4;
3225
3226         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3227         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3228
3229 }
3230
3231 void glStencilMaskSeparate_enc(void *self , GLenum face, GLuint mask)
3232 {
3233
3234         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3235         IOStream *stream = ctx->m_stream;
3236         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3237         bool useChecksum = checksumCalculator->getVersion() > 0;
3238
3239          unsigned char *ptr;
3240          unsigned char *buf;
3241          const size_t sizeWithoutChecksum = 8 + 4 + 4;
3242          const size_t checksumSize = checksumCalculator->checksumByteSize();
3243          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3244         buf = stream->alloc(totalSize);
3245         ptr = buf;
3246         int tmp = OP_glStencilMaskSeparate;memcpy(ptr, &tmp, 4); ptr += 4;
3247         memcpy(ptr, &totalSize, 4);  ptr += 4;
3248
3249                 memcpy(ptr, &face, 4); ptr += 4;
3250                 memcpy(ptr, &mask, 4); ptr += 4;
3251
3252         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3253         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3254
3255 }
3256
3257 void glStencilOp_enc(void *self , GLenum fail, GLenum zfail, GLenum zpass)
3258 {
3259
3260         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3261         IOStream *stream = ctx->m_stream;
3262         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3263         bool useChecksum = checksumCalculator->getVersion() > 0;
3264
3265          unsigned char *ptr;
3266          unsigned char *buf;
3267          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
3268          const size_t checksumSize = checksumCalculator->checksumByteSize();
3269          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3270         buf = stream->alloc(totalSize);
3271         ptr = buf;
3272         int tmp = OP_glStencilOp;memcpy(ptr, &tmp, 4); ptr += 4;
3273         memcpy(ptr, &totalSize, 4);  ptr += 4;
3274
3275                 memcpy(ptr, &fail, 4); ptr += 4;
3276                 memcpy(ptr, &zfail, 4); ptr += 4;
3277                 memcpy(ptr, &zpass, 4); ptr += 4;
3278
3279         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3280         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3281
3282 }
3283
3284 void glStencilOpSeparate_enc(void *self , GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
3285 {
3286
3287         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3288         IOStream *stream = ctx->m_stream;
3289         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3290         bool useChecksum = checksumCalculator->getVersion() > 0;
3291
3292          unsigned char *ptr;
3293          unsigned char *buf;
3294          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
3295          const size_t checksumSize = checksumCalculator->checksumByteSize();
3296          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3297         buf = stream->alloc(totalSize);
3298         ptr = buf;
3299         int tmp = OP_glStencilOpSeparate;memcpy(ptr, &tmp, 4); ptr += 4;
3300         memcpy(ptr, &totalSize, 4);  ptr += 4;
3301
3302                 memcpy(ptr, &face, 4); ptr += 4;
3303                 memcpy(ptr, &fail, 4); ptr += 4;
3304                 memcpy(ptr, &zfail, 4); ptr += 4;
3305                 memcpy(ptr, &zpass, 4); ptr += 4;
3306
3307         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3308         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3309
3310 }
3311
3312 void glTexImage2D_enc(void *self , GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
3313 {
3314
3315         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3316         IOStream *stream = ctx->m_stream;
3317         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3318         bool useChecksum = checksumCalculator->getVersion() > 0;
3319
3320         const unsigned int __size_pixels = ((pixels != NULL) ?  glesv2_enc::pixelDataSize(self, width, height, format, type, 0) : 0);
3321          unsigned char *ptr;
3322          unsigned char *buf;
3323          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
3324          const size_t checksumSize = checksumCalculator->checksumByteSize();
3325          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3326         buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
3327         ptr = buf;
3328         int tmp = OP_glTexImage2D;memcpy(ptr, &tmp, 4); ptr += 4;
3329         memcpy(ptr, &totalSize, 4);  ptr += 4;
3330
3331                 memcpy(ptr, &target, 4); ptr += 4;
3332                 memcpy(ptr, &level, 4); ptr += 4;
3333                 memcpy(ptr, &internalformat, 4); ptr += 4;
3334                 memcpy(ptr, &width, 4); ptr += 4;
3335                 memcpy(ptr, &height, 4); ptr += 4;
3336                 memcpy(ptr, &border, 4); ptr += 4;
3337                 memcpy(ptr, &format, 4); ptr += 4;
3338                 memcpy(ptr, &type, 4); ptr += 4;
3339
3340         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3341         stream->flush();
3342         stream->writeFully(&__size_pixels,4);
3343         if (useChecksum) checksumCalculator->addBuffer(&__size_pixels,4);
3344         if (pixels != NULL) {
3345                 stream->writeFully(pixels, __size_pixels);
3346                 if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
3347         }
3348         buf = stream->alloc(checksumSize);
3349         if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
3350
3351 }
3352
3353 void glTexParameterf_enc(void *self , GLenum target, GLenum pname, GLfloat param)
3354 {
3355
3356         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3357         IOStream *stream = ctx->m_stream;
3358         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3359         bool useChecksum = checksumCalculator->getVersion() > 0;
3360
3361          unsigned char *ptr;
3362          unsigned char *buf;
3363          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
3364          const size_t checksumSize = checksumCalculator->checksumByteSize();
3365          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3366         buf = stream->alloc(totalSize);
3367         ptr = buf;
3368         int tmp = OP_glTexParameterf;memcpy(ptr, &tmp, 4); ptr += 4;
3369         memcpy(ptr, &totalSize, 4);  ptr += 4;
3370
3371                 memcpy(ptr, &target, 4); ptr += 4;
3372                 memcpy(ptr, &pname, 4); ptr += 4;
3373                 memcpy(ptr, &param, 4); ptr += 4;
3374
3375         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3376         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3377
3378 }
3379
3380 void glTexParameterfv_enc(void *self , GLenum target, GLenum pname, const GLfloat* params)
3381 {
3382
3383         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3384         IOStream *stream = ctx->m_stream;
3385         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3386         bool useChecksum = checksumCalculator->getVersion() > 0;
3387
3388         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
3389          unsigned char *ptr;
3390          unsigned char *buf;
3391          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
3392          const size_t checksumSize = checksumCalculator->checksumByteSize();
3393          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3394         buf = stream->alloc(totalSize);
3395         ptr = buf;
3396         int tmp = OP_glTexParameterfv;memcpy(ptr, &tmp, 4); ptr += 4;
3397         memcpy(ptr, &totalSize, 4);  ptr += 4;
3398
3399                 memcpy(ptr, &target, 4); ptr += 4;
3400                 memcpy(ptr, &pname, 4); ptr += 4;
3401         *(unsigned int *)(ptr) = __size_params; ptr += 4;
3402         memcpy(ptr, params, __size_params);ptr += __size_params;
3403
3404         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3405         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3406
3407 }
3408
3409 void glTexParameteri_enc(void *self , GLenum target, GLenum pname, GLint param)
3410 {
3411
3412         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3413         IOStream *stream = ctx->m_stream;
3414         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3415         bool useChecksum = checksumCalculator->getVersion() > 0;
3416
3417          unsigned char *ptr;
3418          unsigned char *buf;
3419          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
3420          const size_t checksumSize = checksumCalculator->checksumByteSize();
3421          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3422         buf = stream->alloc(totalSize);
3423         ptr = buf;
3424         int tmp = OP_glTexParameteri;memcpy(ptr, &tmp, 4); ptr += 4;
3425         memcpy(ptr, &totalSize, 4);  ptr += 4;
3426
3427                 memcpy(ptr, &target, 4); ptr += 4;
3428                 memcpy(ptr, &pname, 4); ptr += 4;
3429                 memcpy(ptr, &param, 4); ptr += 4;
3430
3431         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3432         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3433
3434 }
3435
3436 void glTexParameteriv_enc(void *self , GLenum target, GLenum pname, const GLint* params)
3437 {
3438
3439         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3440         IOStream *stream = ctx->m_stream;
3441         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3442         bool useChecksum = checksumCalculator->getVersion() > 0;
3443
3444         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
3445          unsigned char *ptr;
3446          unsigned char *buf;
3447          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
3448          const size_t checksumSize = checksumCalculator->checksumByteSize();
3449          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3450         buf = stream->alloc(totalSize);
3451         ptr = buf;
3452         int tmp = OP_glTexParameteriv;memcpy(ptr, &tmp, 4); ptr += 4;
3453         memcpy(ptr, &totalSize, 4);  ptr += 4;
3454
3455                 memcpy(ptr, &target, 4); ptr += 4;
3456                 memcpy(ptr, &pname, 4); ptr += 4;
3457         *(unsigned int *)(ptr) = __size_params; ptr += 4;
3458         memcpy(ptr, params, __size_params);ptr += __size_params;
3459
3460         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3461         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3462
3463 }
3464
3465 void glTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
3466 {
3467
3468         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3469         IOStream *stream = ctx->m_stream;
3470         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3471         bool useChecksum = checksumCalculator->getVersion() > 0;
3472
3473         const unsigned int __size_pixels = ((pixels != NULL) ?  glesv2_enc::pixelDataSize(self, width, height, format, type, 0) : 0);
3474          unsigned char *ptr;
3475          unsigned char *buf;
3476          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
3477          const size_t checksumSize = checksumCalculator->checksumByteSize();
3478          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3479         buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
3480         ptr = buf;
3481         int tmp = OP_glTexSubImage2D;memcpy(ptr, &tmp, 4); ptr += 4;
3482         memcpy(ptr, &totalSize, 4);  ptr += 4;
3483
3484                 memcpy(ptr, &target, 4); ptr += 4;
3485                 memcpy(ptr, &level, 4); ptr += 4;
3486                 memcpy(ptr, &xoffset, 4); ptr += 4;
3487                 memcpy(ptr, &yoffset, 4); ptr += 4;
3488                 memcpy(ptr, &width, 4); ptr += 4;
3489                 memcpy(ptr, &height, 4); ptr += 4;
3490                 memcpy(ptr, &format, 4); ptr += 4;
3491                 memcpy(ptr, &type, 4); ptr += 4;
3492
3493         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3494         stream->flush();
3495         stream->writeFully(&__size_pixels,4);
3496         if (useChecksum) checksumCalculator->addBuffer(&__size_pixels,4);
3497         if (pixels != NULL) {
3498                 stream->writeFully(pixels, __size_pixels);
3499                 if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
3500         }
3501         buf = stream->alloc(checksumSize);
3502         if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
3503
3504 }
3505
3506 void glUniform1f_enc(void *self , GLint location, GLfloat x)
3507 {
3508
3509         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3510         IOStream *stream = ctx->m_stream;
3511         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3512         bool useChecksum = checksumCalculator->getVersion() > 0;
3513
3514          unsigned char *ptr;
3515          unsigned char *buf;
3516          const size_t sizeWithoutChecksum = 8 + 4 + 4;
3517          const size_t checksumSize = checksumCalculator->checksumByteSize();
3518          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3519         buf = stream->alloc(totalSize);
3520         ptr = buf;
3521         int tmp = OP_glUniform1f;memcpy(ptr, &tmp, 4); ptr += 4;
3522         memcpy(ptr, &totalSize, 4);  ptr += 4;
3523
3524                 memcpy(ptr, &location, 4); ptr += 4;
3525                 memcpy(ptr, &x, 4); ptr += 4;
3526
3527         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3528         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3529
3530 }
3531
3532 void glUniform1fv_enc(void *self , GLint location, GLsizei count, const GLfloat* v)
3533 {
3534
3535         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3536         IOStream *stream = ctx->m_stream;
3537         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3538         bool useChecksum = checksumCalculator->getVersion() > 0;
3539
3540         const unsigned int __size_v =  (count * sizeof(GLfloat));
3541          unsigned char *ptr;
3542          unsigned char *buf;
3543          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_v + 1*4;
3544          const size_t checksumSize = checksumCalculator->checksumByteSize();
3545          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3546         buf = stream->alloc(totalSize);
3547         ptr = buf;
3548         int tmp = OP_glUniform1fv;memcpy(ptr, &tmp, 4); ptr += 4;
3549         memcpy(ptr, &totalSize, 4);  ptr += 4;
3550
3551                 memcpy(ptr, &location, 4); ptr += 4;
3552                 memcpy(ptr, &count, 4); ptr += 4;
3553         *(unsigned int *)(ptr) = __size_v; ptr += 4;
3554         memcpy(ptr, v, __size_v);ptr += __size_v;
3555
3556         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3557         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3558
3559 }
3560
3561 void glUniform1i_enc(void *self , GLint location, GLint x)
3562 {
3563
3564         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3565         IOStream *stream = ctx->m_stream;
3566         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3567         bool useChecksum = checksumCalculator->getVersion() > 0;
3568
3569          unsigned char *ptr;
3570          unsigned char *buf;
3571          const size_t sizeWithoutChecksum = 8 + 4 + 4;
3572          const size_t checksumSize = checksumCalculator->checksumByteSize();
3573          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3574         buf = stream->alloc(totalSize);
3575         ptr = buf;
3576         int tmp = OP_glUniform1i;memcpy(ptr, &tmp, 4); ptr += 4;
3577         memcpy(ptr, &totalSize, 4);  ptr += 4;
3578
3579                 memcpy(ptr, &location, 4); ptr += 4;
3580                 memcpy(ptr, &x, 4); ptr += 4;
3581
3582         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3583         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3584
3585 }
3586
3587 void glUniform1iv_enc(void *self , GLint location, GLsizei count, const GLint* v)
3588 {
3589
3590         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3591         IOStream *stream = ctx->m_stream;
3592         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3593         bool useChecksum = checksumCalculator->getVersion() > 0;
3594
3595         const unsigned int __size_v =  (count * sizeof(GLint));
3596          unsigned char *ptr;
3597          unsigned char *buf;
3598          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_v + 1*4;
3599          const size_t checksumSize = checksumCalculator->checksumByteSize();
3600          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3601         buf = stream->alloc(totalSize);
3602         ptr = buf;
3603         int tmp = OP_glUniform1iv;memcpy(ptr, &tmp, 4); ptr += 4;
3604         memcpy(ptr, &totalSize, 4);  ptr += 4;
3605
3606                 memcpy(ptr, &location, 4); ptr += 4;
3607                 memcpy(ptr, &count, 4); ptr += 4;
3608         *(unsigned int *)(ptr) = __size_v; ptr += 4;
3609         memcpy(ptr, v, __size_v);ptr += __size_v;
3610
3611         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3612         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3613
3614 }
3615
3616 void glUniform2f_enc(void *self , GLint location, GLfloat x, GLfloat y)
3617 {
3618
3619         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3620         IOStream *stream = ctx->m_stream;
3621         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3622         bool useChecksum = checksumCalculator->getVersion() > 0;
3623
3624          unsigned char *ptr;
3625          unsigned char *buf;
3626          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
3627          const size_t checksumSize = checksumCalculator->checksumByteSize();
3628          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3629         buf = stream->alloc(totalSize);
3630         ptr = buf;
3631         int tmp = OP_glUniform2f;memcpy(ptr, &tmp, 4); ptr += 4;
3632         memcpy(ptr, &totalSize, 4);  ptr += 4;
3633
3634                 memcpy(ptr, &location, 4); ptr += 4;
3635                 memcpy(ptr, &x, 4); ptr += 4;
3636                 memcpy(ptr, &y, 4); ptr += 4;
3637
3638         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3639         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3640
3641 }
3642
3643 void glUniform2fv_enc(void *self , GLint location, GLsizei count, const GLfloat* v)
3644 {
3645
3646         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3647         IOStream *stream = ctx->m_stream;
3648         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3649         bool useChecksum = checksumCalculator->getVersion() > 0;
3650
3651         const unsigned int __size_v =  (count * 2 * sizeof(GLfloat));
3652          unsigned char *ptr;
3653          unsigned char *buf;
3654          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_v + 1*4;
3655          const size_t checksumSize = checksumCalculator->checksumByteSize();
3656          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3657         buf = stream->alloc(totalSize);
3658         ptr = buf;
3659         int tmp = OP_glUniform2fv;memcpy(ptr, &tmp, 4); ptr += 4;
3660         memcpy(ptr, &totalSize, 4);  ptr += 4;
3661
3662                 memcpy(ptr, &location, 4); ptr += 4;
3663                 memcpy(ptr, &count, 4); ptr += 4;
3664         *(unsigned int *)(ptr) = __size_v; ptr += 4;
3665         memcpy(ptr, v, __size_v);ptr += __size_v;
3666
3667         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3668         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3669
3670 }
3671
3672 void glUniform2i_enc(void *self , GLint location, GLint x, GLint y)
3673 {
3674
3675         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3676         IOStream *stream = ctx->m_stream;
3677         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3678         bool useChecksum = checksumCalculator->getVersion() > 0;
3679
3680          unsigned char *ptr;
3681          unsigned char *buf;
3682          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
3683          const size_t checksumSize = checksumCalculator->checksumByteSize();
3684          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3685         buf = stream->alloc(totalSize);
3686         ptr = buf;
3687         int tmp = OP_glUniform2i;memcpy(ptr, &tmp, 4); ptr += 4;
3688         memcpy(ptr, &totalSize, 4);  ptr += 4;
3689
3690                 memcpy(ptr, &location, 4); ptr += 4;
3691                 memcpy(ptr, &x, 4); ptr += 4;
3692                 memcpy(ptr, &y, 4); ptr += 4;
3693
3694         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3695         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3696
3697 }
3698
3699 void glUniform2iv_enc(void *self , GLint location, GLsizei count, const GLint* v)
3700 {
3701
3702         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3703         IOStream *stream = ctx->m_stream;
3704         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3705         bool useChecksum = checksumCalculator->getVersion() > 0;
3706
3707         const unsigned int __size_v =  (count * 2 * sizeof(GLint));
3708          unsigned char *ptr;
3709          unsigned char *buf;
3710          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_v + 1*4;
3711          const size_t checksumSize = checksumCalculator->checksumByteSize();
3712          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3713         buf = stream->alloc(totalSize);
3714         ptr = buf;
3715         int tmp = OP_glUniform2iv;memcpy(ptr, &tmp, 4); ptr += 4;
3716         memcpy(ptr, &totalSize, 4);  ptr += 4;
3717
3718                 memcpy(ptr, &location, 4); ptr += 4;
3719                 memcpy(ptr, &count, 4); ptr += 4;
3720         *(unsigned int *)(ptr) = __size_v; ptr += 4;
3721         memcpy(ptr, v, __size_v);ptr += __size_v;
3722
3723         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3724         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3725
3726 }
3727
3728 void glUniform3f_enc(void *self , GLint location, GLfloat x, GLfloat y, GLfloat z)
3729 {
3730
3731         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3732         IOStream *stream = ctx->m_stream;
3733         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3734         bool useChecksum = checksumCalculator->getVersion() > 0;
3735
3736          unsigned char *ptr;
3737          unsigned char *buf;
3738          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
3739          const size_t checksumSize = checksumCalculator->checksumByteSize();
3740          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3741         buf = stream->alloc(totalSize);
3742         ptr = buf;
3743         int tmp = OP_glUniform3f;memcpy(ptr, &tmp, 4); ptr += 4;
3744         memcpy(ptr, &totalSize, 4);  ptr += 4;
3745
3746                 memcpy(ptr, &location, 4); ptr += 4;
3747                 memcpy(ptr, &x, 4); ptr += 4;
3748                 memcpy(ptr, &y, 4); ptr += 4;
3749                 memcpy(ptr, &z, 4); ptr += 4;
3750
3751         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3752         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3753
3754 }
3755
3756 void glUniform3fv_enc(void *self , GLint location, GLsizei count, const GLfloat* v)
3757 {
3758
3759         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3760         IOStream *stream = ctx->m_stream;
3761         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3762         bool useChecksum = checksumCalculator->getVersion() > 0;
3763
3764         const unsigned int __size_v =  (count * 3 * sizeof(GLfloat));
3765          unsigned char *ptr;
3766          unsigned char *buf;
3767          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_v + 1*4;
3768          const size_t checksumSize = checksumCalculator->checksumByteSize();
3769          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3770         buf = stream->alloc(totalSize);
3771         ptr = buf;
3772         int tmp = OP_glUniform3fv;memcpy(ptr, &tmp, 4); ptr += 4;
3773         memcpy(ptr, &totalSize, 4);  ptr += 4;
3774
3775                 memcpy(ptr, &location, 4); ptr += 4;
3776                 memcpy(ptr, &count, 4); ptr += 4;
3777         *(unsigned int *)(ptr) = __size_v; ptr += 4;
3778         memcpy(ptr, v, __size_v);ptr += __size_v;
3779
3780         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3781         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3782
3783 }
3784
3785 void glUniform3i_enc(void *self , GLint location, GLint x, GLint y, GLint z)
3786 {
3787
3788         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3789         IOStream *stream = ctx->m_stream;
3790         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3791         bool useChecksum = checksumCalculator->getVersion() > 0;
3792
3793          unsigned char *ptr;
3794          unsigned char *buf;
3795          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
3796          const size_t checksumSize = checksumCalculator->checksumByteSize();
3797          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3798         buf = stream->alloc(totalSize);
3799         ptr = buf;
3800         int tmp = OP_glUniform3i;memcpy(ptr, &tmp, 4); ptr += 4;
3801         memcpy(ptr, &totalSize, 4);  ptr += 4;
3802
3803                 memcpy(ptr, &location, 4); ptr += 4;
3804                 memcpy(ptr, &x, 4); ptr += 4;
3805                 memcpy(ptr, &y, 4); ptr += 4;
3806                 memcpy(ptr, &z, 4); ptr += 4;
3807
3808         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3809         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3810
3811 }
3812
3813 void glUniform3iv_enc(void *self , GLint location, GLsizei count, const GLint* v)
3814 {
3815
3816         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3817         IOStream *stream = ctx->m_stream;
3818         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3819         bool useChecksum = checksumCalculator->getVersion() > 0;
3820
3821         const unsigned int __size_v =  (3 * count * sizeof(GLint));
3822          unsigned char *ptr;
3823          unsigned char *buf;
3824          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_v + 1*4;
3825          const size_t checksumSize = checksumCalculator->checksumByteSize();
3826          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3827         buf = stream->alloc(totalSize);
3828         ptr = buf;
3829         int tmp = OP_glUniform3iv;memcpy(ptr, &tmp, 4); ptr += 4;
3830         memcpy(ptr, &totalSize, 4);  ptr += 4;
3831
3832                 memcpy(ptr, &location, 4); ptr += 4;
3833                 memcpy(ptr, &count, 4); ptr += 4;
3834         *(unsigned int *)(ptr) = __size_v; ptr += 4;
3835         memcpy(ptr, v, __size_v);ptr += __size_v;
3836
3837         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3838         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3839
3840 }
3841
3842 void glUniform4f_enc(void *self , GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
3843 {
3844
3845         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3846         IOStream *stream = ctx->m_stream;
3847         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3848         bool useChecksum = checksumCalculator->getVersion() > 0;
3849
3850          unsigned char *ptr;
3851          unsigned char *buf;
3852          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
3853          const size_t checksumSize = checksumCalculator->checksumByteSize();
3854          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3855         buf = stream->alloc(totalSize);
3856         ptr = buf;
3857         int tmp = OP_glUniform4f;memcpy(ptr, &tmp, 4); ptr += 4;
3858         memcpy(ptr, &totalSize, 4);  ptr += 4;
3859
3860                 memcpy(ptr, &location, 4); ptr += 4;
3861                 memcpy(ptr, &x, 4); ptr += 4;
3862                 memcpy(ptr, &y, 4); ptr += 4;
3863                 memcpy(ptr, &z, 4); ptr += 4;
3864                 memcpy(ptr, &w, 4); ptr += 4;
3865
3866         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3867         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3868
3869 }
3870
3871 void glUniform4fv_enc(void *self , GLint location, GLsizei count, const GLfloat* v)
3872 {
3873
3874         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3875         IOStream *stream = ctx->m_stream;
3876         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3877         bool useChecksum = checksumCalculator->getVersion() > 0;
3878
3879         const unsigned int __size_v =  (4 * count * sizeof(GLfloat));
3880          unsigned char *ptr;
3881          unsigned char *buf;
3882          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_v + 1*4;
3883          const size_t checksumSize = checksumCalculator->checksumByteSize();
3884          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3885         buf = stream->alloc(totalSize);
3886         ptr = buf;
3887         int tmp = OP_glUniform4fv;memcpy(ptr, &tmp, 4); ptr += 4;
3888         memcpy(ptr, &totalSize, 4);  ptr += 4;
3889
3890                 memcpy(ptr, &location, 4); ptr += 4;
3891                 memcpy(ptr, &count, 4); ptr += 4;
3892         *(unsigned int *)(ptr) = __size_v; ptr += 4;
3893         memcpy(ptr, v, __size_v);ptr += __size_v;
3894
3895         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3896         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3897
3898 }
3899
3900 void glUniform4i_enc(void *self , GLint location, GLint x, GLint y, GLint z, GLint w)
3901 {
3902
3903         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3904         IOStream *stream = ctx->m_stream;
3905         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3906         bool useChecksum = checksumCalculator->getVersion() > 0;
3907
3908          unsigned char *ptr;
3909          unsigned char *buf;
3910          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
3911          const size_t checksumSize = checksumCalculator->checksumByteSize();
3912          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3913         buf = stream->alloc(totalSize);
3914         ptr = buf;
3915         int tmp = OP_glUniform4i;memcpy(ptr, &tmp, 4); ptr += 4;
3916         memcpy(ptr, &totalSize, 4);  ptr += 4;
3917
3918                 memcpy(ptr, &location, 4); ptr += 4;
3919                 memcpy(ptr, &x, 4); ptr += 4;
3920                 memcpy(ptr, &y, 4); ptr += 4;
3921                 memcpy(ptr, &z, 4); ptr += 4;
3922                 memcpy(ptr, &w, 4); ptr += 4;
3923
3924         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3925         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3926
3927 }
3928
3929 void glUniform4iv_enc(void *self , GLint location, GLsizei count, const GLint* v)
3930 {
3931
3932         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3933         IOStream *stream = ctx->m_stream;
3934         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3935         bool useChecksum = checksumCalculator->getVersion() > 0;
3936
3937         const unsigned int __size_v =  (4 * count * sizeof(GLint));
3938          unsigned char *ptr;
3939          unsigned char *buf;
3940          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_v + 1*4;
3941          const size_t checksumSize = checksumCalculator->checksumByteSize();
3942          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3943         buf = stream->alloc(totalSize);
3944         ptr = buf;
3945         int tmp = OP_glUniform4iv;memcpy(ptr, &tmp, 4); ptr += 4;
3946         memcpy(ptr, &totalSize, 4);  ptr += 4;
3947
3948                 memcpy(ptr, &location, 4); ptr += 4;
3949                 memcpy(ptr, &count, 4); ptr += 4;
3950         *(unsigned int *)(ptr) = __size_v; ptr += 4;
3951         memcpy(ptr, v, __size_v);ptr += __size_v;
3952
3953         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3954         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3955
3956 }
3957
3958 void glUniformMatrix2fv_enc(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
3959 {
3960
3961         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3962         IOStream *stream = ctx->m_stream;
3963         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3964         bool useChecksum = checksumCalculator->getVersion() > 0;
3965
3966         const unsigned int __size_value =  (count * 4 * sizeof(GLfloat));
3967          unsigned char *ptr;
3968          unsigned char *buf;
3969          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 1 + __size_value + 1*4;
3970          const size_t checksumSize = checksumCalculator->checksumByteSize();
3971          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3972         buf = stream->alloc(totalSize);
3973         ptr = buf;
3974         int tmp = OP_glUniformMatrix2fv;memcpy(ptr, &tmp, 4); ptr += 4;
3975         memcpy(ptr, &totalSize, 4);  ptr += 4;
3976
3977                 memcpy(ptr, &location, 4); ptr += 4;
3978                 memcpy(ptr, &count, 4); ptr += 4;
3979                 memcpy(ptr, &transpose, 1); ptr += 1;
3980         *(unsigned int *)(ptr) = __size_value; ptr += 4;
3981         memcpy(ptr, value, __size_value);ptr += __size_value;
3982
3983         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3984         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3985
3986 }
3987
3988 void glUniformMatrix3fv_enc(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
3989 {
3990
3991         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
3992         IOStream *stream = ctx->m_stream;
3993         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3994         bool useChecksum = checksumCalculator->getVersion() > 0;
3995
3996         const unsigned int __size_value =  (count * 9 * sizeof(GLfloat));
3997          unsigned char *ptr;
3998          unsigned char *buf;
3999          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 1 + __size_value + 1*4;
4000          const size_t checksumSize = checksumCalculator->checksumByteSize();
4001          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4002         buf = stream->alloc(totalSize);
4003         ptr = buf;
4004         int tmp = OP_glUniformMatrix3fv;memcpy(ptr, &tmp, 4); ptr += 4;
4005         memcpy(ptr, &totalSize, 4);  ptr += 4;
4006
4007                 memcpy(ptr, &location, 4); ptr += 4;
4008                 memcpy(ptr, &count, 4); ptr += 4;
4009                 memcpy(ptr, &transpose, 1); ptr += 1;
4010         *(unsigned int *)(ptr) = __size_value; ptr += 4;
4011         memcpy(ptr, value, __size_value);ptr += __size_value;
4012
4013         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4014         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4015
4016 }
4017
4018 void glUniformMatrix4fv_enc(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
4019 {
4020
4021         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4022         IOStream *stream = ctx->m_stream;
4023         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4024         bool useChecksum = checksumCalculator->getVersion() > 0;
4025
4026         const unsigned int __size_value =  (count * 16 * sizeof(GLfloat));
4027          unsigned char *ptr;
4028          unsigned char *buf;
4029          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 1 + __size_value + 1*4;
4030          const size_t checksumSize = checksumCalculator->checksumByteSize();
4031          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4032         buf = stream->alloc(totalSize);
4033         ptr = buf;
4034         int tmp = OP_glUniformMatrix4fv;memcpy(ptr, &tmp, 4); ptr += 4;
4035         memcpy(ptr, &totalSize, 4);  ptr += 4;
4036
4037                 memcpy(ptr, &location, 4); ptr += 4;
4038                 memcpy(ptr, &count, 4); ptr += 4;
4039                 memcpy(ptr, &transpose, 1); ptr += 1;
4040         *(unsigned int *)(ptr) = __size_value; ptr += 4;
4041         memcpy(ptr, value, __size_value);ptr += __size_value;
4042
4043         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4044         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4045
4046 }
4047
4048 void glUseProgram_enc(void *self , GLuint program)
4049 {
4050
4051         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4052         IOStream *stream = ctx->m_stream;
4053         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4054         bool useChecksum = checksumCalculator->getVersion() > 0;
4055
4056          unsigned char *ptr;
4057          unsigned char *buf;
4058          const size_t sizeWithoutChecksum = 8 + 4;
4059          const size_t checksumSize = checksumCalculator->checksumByteSize();
4060          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4061         buf = stream->alloc(totalSize);
4062         ptr = buf;
4063         int tmp = OP_glUseProgram;memcpy(ptr, &tmp, 4); ptr += 4;
4064         memcpy(ptr, &totalSize, 4);  ptr += 4;
4065
4066                 memcpy(ptr, &program, 4); ptr += 4;
4067
4068         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4069         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4070
4071 }
4072
4073 void glValidateProgram_enc(void *self , GLuint program)
4074 {
4075
4076         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4077         IOStream *stream = ctx->m_stream;
4078         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4079         bool useChecksum = checksumCalculator->getVersion() > 0;
4080
4081          unsigned char *ptr;
4082          unsigned char *buf;
4083          const size_t sizeWithoutChecksum = 8 + 4;
4084          const size_t checksumSize = checksumCalculator->checksumByteSize();
4085          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4086         buf = stream->alloc(totalSize);
4087         ptr = buf;
4088         int tmp = OP_glValidateProgram;memcpy(ptr, &tmp, 4); ptr += 4;
4089         memcpy(ptr, &totalSize, 4);  ptr += 4;
4090
4091                 memcpy(ptr, &program, 4); ptr += 4;
4092
4093         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4094         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4095
4096 }
4097
4098 void glVertexAttrib1f_enc(void *self , GLuint indx, GLfloat x)
4099 {
4100
4101         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4102         IOStream *stream = ctx->m_stream;
4103         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4104         bool useChecksum = checksumCalculator->getVersion() > 0;
4105
4106          unsigned char *ptr;
4107          unsigned char *buf;
4108          const size_t sizeWithoutChecksum = 8 + 4 + 4;
4109          const size_t checksumSize = checksumCalculator->checksumByteSize();
4110          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4111         buf = stream->alloc(totalSize);
4112         ptr = buf;
4113         int tmp = OP_glVertexAttrib1f;memcpy(ptr, &tmp, 4); ptr += 4;
4114         memcpy(ptr, &totalSize, 4);  ptr += 4;
4115
4116                 memcpy(ptr, &indx, 4); ptr += 4;
4117                 memcpy(ptr, &x, 4); ptr += 4;
4118
4119         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4120         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4121
4122 }
4123
4124 void glVertexAttrib1fv_enc(void *self , GLuint indx, const GLfloat* values)
4125 {
4126
4127         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4128         IOStream *stream = ctx->m_stream;
4129         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4130         bool useChecksum = checksumCalculator->getVersion() > 0;
4131
4132         const unsigned int __size_values =  (sizeof(GLfloat));
4133          unsigned char *ptr;
4134          unsigned char *buf;
4135          const size_t sizeWithoutChecksum = 8 + 4 + __size_values + 1*4;
4136          const size_t checksumSize = checksumCalculator->checksumByteSize();
4137          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4138         buf = stream->alloc(totalSize);
4139         ptr = buf;
4140         int tmp = OP_glVertexAttrib1fv;memcpy(ptr, &tmp, 4); ptr += 4;
4141         memcpy(ptr, &totalSize, 4);  ptr += 4;
4142
4143                 memcpy(ptr, &indx, 4); ptr += 4;
4144         *(unsigned int *)(ptr) = __size_values; ptr += 4;
4145         memcpy(ptr, values, __size_values);ptr += __size_values;
4146
4147         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4148         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4149
4150 }
4151
4152 void glVertexAttrib2f_enc(void *self , GLuint indx, GLfloat x, GLfloat y)
4153 {
4154
4155         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4156         IOStream *stream = ctx->m_stream;
4157         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4158         bool useChecksum = checksumCalculator->getVersion() > 0;
4159
4160          unsigned char *ptr;
4161          unsigned char *buf;
4162          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
4163          const size_t checksumSize = checksumCalculator->checksumByteSize();
4164          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4165         buf = stream->alloc(totalSize);
4166         ptr = buf;
4167         int tmp = OP_glVertexAttrib2f;memcpy(ptr, &tmp, 4); ptr += 4;
4168         memcpy(ptr, &totalSize, 4);  ptr += 4;
4169
4170                 memcpy(ptr, &indx, 4); ptr += 4;
4171                 memcpy(ptr, &x, 4); ptr += 4;
4172                 memcpy(ptr, &y, 4); ptr += 4;
4173
4174         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4175         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4176
4177 }
4178
4179 void glVertexAttrib2fv_enc(void *self , GLuint indx, const GLfloat* values)
4180 {
4181
4182         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4183         IOStream *stream = ctx->m_stream;
4184         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4185         bool useChecksum = checksumCalculator->getVersion() > 0;
4186
4187         const unsigned int __size_values =  (2 * sizeof(GLfloat));
4188          unsigned char *ptr;
4189          unsigned char *buf;
4190          const size_t sizeWithoutChecksum = 8 + 4 + __size_values + 1*4;
4191          const size_t checksumSize = checksumCalculator->checksumByteSize();
4192          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4193         buf = stream->alloc(totalSize);
4194         ptr = buf;
4195         int tmp = OP_glVertexAttrib2fv;memcpy(ptr, &tmp, 4); ptr += 4;
4196         memcpy(ptr, &totalSize, 4);  ptr += 4;
4197
4198                 memcpy(ptr, &indx, 4); ptr += 4;
4199         *(unsigned int *)(ptr) = __size_values; ptr += 4;
4200         memcpy(ptr, values, __size_values);ptr += __size_values;
4201
4202         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4203         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4204
4205 }
4206
4207 void glVertexAttrib3f_enc(void *self , GLuint indx, GLfloat x, GLfloat y, GLfloat z)
4208 {
4209
4210         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4211         IOStream *stream = ctx->m_stream;
4212         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4213         bool useChecksum = checksumCalculator->getVersion() > 0;
4214
4215          unsigned char *ptr;
4216          unsigned char *buf;
4217          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
4218          const size_t checksumSize = checksumCalculator->checksumByteSize();
4219          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4220         buf = stream->alloc(totalSize);
4221         ptr = buf;
4222         int tmp = OP_glVertexAttrib3f;memcpy(ptr, &tmp, 4); ptr += 4;
4223         memcpy(ptr, &totalSize, 4);  ptr += 4;
4224
4225                 memcpy(ptr, &indx, 4); ptr += 4;
4226                 memcpy(ptr, &x, 4); ptr += 4;
4227                 memcpy(ptr, &y, 4); ptr += 4;
4228                 memcpy(ptr, &z, 4); ptr += 4;
4229
4230         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4231         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4232
4233 }
4234
4235 void glVertexAttrib3fv_enc(void *self , GLuint indx, const GLfloat* values)
4236 {
4237
4238         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4239         IOStream *stream = ctx->m_stream;
4240         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4241         bool useChecksum = checksumCalculator->getVersion() > 0;
4242
4243         const unsigned int __size_values =  (3 * sizeof(GLfloat));
4244          unsigned char *ptr;
4245          unsigned char *buf;
4246          const size_t sizeWithoutChecksum = 8 + 4 + __size_values + 1*4;
4247          const size_t checksumSize = checksumCalculator->checksumByteSize();
4248          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4249         buf = stream->alloc(totalSize);
4250         ptr = buf;
4251         int tmp = OP_glVertexAttrib3fv;memcpy(ptr, &tmp, 4); ptr += 4;
4252         memcpy(ptr, &totalSize, 4);  ptr += 4;
4253
4254                 memcpy(ptr, &indx, 4); ptr += 4;
4255         *(unsigned int *)(ptr) = __size_values; ptr += 4;
4256         memcpy(ptr, values, __size_values);ptr += __size_values;
4257
4258         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4259         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4260
4261 }
4262
4263 void glVertexAttrib4f_enc(void *self , GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
4264 {
4265
4266         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4267         IOStream *stream = ctx->m_stream;
4268         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4269         bool useChecksum = checksumCalculator->getVersion() > 0;
4270
4271          unsigned char *ptr;
4272          unsigned char *buf;
4273          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
4274          const size_t checksumSize = checksumCalculator->checksumByteSize();
4275          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4276         buf = stream->alloc(totalSize);
4277         ptr = buf;
4278         int tmp = OP_glVertexAttrib4f;memcpy(ptr, &tmp, 4); ptr += 4;
4279         memcpy(ptr, &totalSize, 4);  ptr += 4;
4280
4281                 memcpy(ptr, &indx, 4); ptr += 4;
4282                 memcpy(ptr, &x, 4); ptr += 4;
4283                 memcpy(ptr, &y, 4); ptr += 4;
4284                 memcpy(ptr, &z, 4); ptr += 4;
4285                 memcpy(ptr, &w, 4); ptr += 4;
4286
4287         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4288         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4289
4290 }
4291
4292 void glVertexAttrib4fv_enc(void *self , GLuint indx, const GLfloat* values)
4293 {
4294
4295         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4296         IOStream *stream = ctx->m_stream;
4297         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4298         bool useChecksum = checksumCalculator->getVersion() > 0;
4299
4300         const unsigned int __size_values =  (4 * sizeof(GLfloat));
4301          unsigned char *ptr;
4302          unsigned char *buf;
4303          const size_t sizeWithoutChecksum = 8 + 4 + __size_values + 1*4;
4304          const size_t checksumSize = checksumCalculator->checksumByteSize();
4305          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4306         buf = stream->alloc(totalSize);
4307         ptr = buf;
4308         int tmp = OP_glVertexAttrib4fv;memcpy(ptr, &tmp, 4); ptr += 4;
4309         memcpy(ptr, &totalSize, 4);  ptr += 4;
4310
4311                 memcpy(ptr, &indx, 4); ptr += 4;
4312         *(unsigned int *)(ptr) = __size_values; ptr += 4;
4313         memcpy(ptr, values, __size_values);ptr += __size_values;
4314
4315         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4316         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4317
4318 }
4319
4320 void glViewport_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height)
4321 {
4322
4323         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4324         IOStream *stream = ctx->m_stream;
4325         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4326         bool useChecksum = checksumCalculator->getVersion() > 0;
4327
4328          unsigned char *ptr;
4329          unsigned char *buf;
4330          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
4331          const size_t checksumSize = checksumCalculator->checksumByteSize();
4332          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4333         buf = stream->alloc(totalSize);
4334         ptr = buf;
4335         int tmp = OP_glViewport;memcpy(ptr, &tmp, 4); ptr += 4;
4336         memcpy(ptr, &totalSize, 4);  ptr += 4;
4337
4338                 memcpy(ptr, &x, 4); ptr += 4;
4339                 memcpy(ptr, &y, 4); ptr += 4;
4340                 memcpy(ptr, &width, 4); ptr += 4;
4341                 memcpy(ptr, &height, 4); ptr += 4;
4342
4343         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4344         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4345
4346 }
4347
4348 void glEGLImageTargetTexture2DOES_enc(void *self , GLenum target, GLeglImageOES image)
4349 {
4350
4351         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4352         IOStream *stream = ctx->m_stream;
4353         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4354         bool useChecksum = checksumCalculator->getVersion() > 0;
4355
4356          unsigned char *ptr;
4357          unsigned char *buf;
4358          const size_t sizeWithoutChecksum = 8 + 4 + 4;
4359          const size_t checksumSize = checksumCalculator->checksumByteSize();
4360          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4361         buf = stream->alloc(totalSize);
4362         ptr = buf;
4363         int tmp = OP_glEGLImageTargetTexture2DOES;memcpy(ptr, &tmp, 4); ptr += 4;
4364         memcpy(ptr, &totalSize, 4);  ptr += 4;
4365
4366                 memcpy(ptr, &target, 4); ptr += 4;
4367                 memcpy(ptr, &image, 4); ptr += 4;
4368
4369         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4370         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4371
4372 }
4373
4374 void glEGLImageTargetRenderbufferStorageOES_enc(void *self , GLenum target, GLeglImageOES image)
4375 {
4376
4377         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4378         IOStream *stream = ctx->m_stream;
4379         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4380         bool useChecksum = checksumCalculator->getVersion() > 0;
4381
4382          unsigned char *ptr;
4383          unsigned char *buf;
4384          const size_t sizeWithoutChecksum = 8 + 4 + 4;
4385          const size_t checksumSize = checksumCalculator->checksumByteSize();
4386          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4387         buf = stream->alloc(totalSize);
4388         ptr = buf;
4389         int tmp = OP_glEGLImageTargetRenderbufferStorageOES;memcpy(ptr, &tmp, 4); ptr += 4;
4390         memcpy(ptr, &totalSize, 4);  ptr += 4;
4391
4392                 memcpy(ptr, &target, 4); ptr += 4;
4393                 memcpy(ptr, &image, 4); ptr += 4;
4394
4395         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4396         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4397
4398 }
4399
4400 GLboolean glUnmapBufferOES_enc(void *self , GLenum target)
4401 {
4402
4403         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4404         IOStream *stream = ctx->m_stream;
4405         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4406         bool useChecksum = checksumCalculator->getVersion() > 0;
4407
4408          unsigned char *ptr;
4409          unsigned char *buf;
4410          const size_t sizeWithoutChecksum = 8 + 4;
4411          const size_t checksumSize = checksumCalculator->checksumByteSize();
4412          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4413         buf = stream->alloc(totalSize);
4414         ptr = buf;
4415         int tmp = OP_glUnmapBufferOES;memcpy(ptr, &tmp, 4); ptr += 4;
4416         memcpy(ptr, &totalSize, 4);  ptr += 4;
4417
4418                 memcpy(ptr, &target, 4); ptr += 4;
4419
4420         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4421         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4422
4423
4424         GLboolean retval;
4425         stream->readback(&retval, 1);
4426         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
4427         if (useChecksum) {
4428                 unsigned char *checksumBufPtr = NULL;
4429                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
4430                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
4431                 stream->readback(checksumBufPtr, checksumSize);
4432                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
4433                         ALOGE("glUnmapBufferOES: GL communication error, please report this issue to b.android.com.\n");
4434                         abort();
4435                 }
4436         }
4437         return retval;
4438 }
4439
4440 void glTexImage3DOES_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
4441 {
4442
4443         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4444         IOStream *stream = ctx->m_stream;
4445         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4446         bool useChecksum = checksumCalculator->getVersion() > 0;
4447
4448         const unsigned int __size_pixels = ((pixels != NULL) ?  glesv2_enc::pixelDataSize3D(self, width, height, depth, format, type, 0) : 0);
4449          unsigned char *ptr;
4450          unsigned char *buf;
4451          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
4452          const size_t checksumSize = checksumCalculator->checksumByteSize();
4453          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4454         buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
4455         ptr = buf;
4456         int tmp = OP_glTexImage3DOES;memcpy(ptr, &tmp, 4); ptr += 4;
4457         memcpy(ptr, &totalSize, 4);  ptr += 4;
4458
4459                 memcpy(ptr, &target, 4); ptr += 4;
4460                 memcpy(ptr, &level, 4); ptr += 4;
4461                 memcpy(ptr, &internalformat, 4); ptr += 4;
4462                 memcpy(ptr, &width, 4); ptr += 4;
4463                 memcpy(ptr, &height, 4); ptr += 4;
4464                 memcpy(ptr, &depth, 4); ptr += 4;
4465                 memcpy(ptr, &border, 4); ptr += 4;
4466                 memcpy(ptr, &format, 4); ptr += 4;
4467                 memcpy(ptr, &type, 4); ptr += 4;
4468
4469         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4470         stream->flush();
4471         stream->writeFully(&__size_pixels,4);
4472         if (useChecksum) checksumCalculator->addBuffer(&__size_pixels,4);
4473         if (pixels != NULL) {
4474                 stream->writeFully(pixels, __size_pixels);
4475                 if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
4476         }
4477         buf = stream->alloc(checksumSize);
4478         if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
4479
4480 }
4481
4482 void glTexSubImage3DOES_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels)
4483 {
4484
4485         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4486         IOStream *stream = ctx->m_stream;
4487         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4488         bool useChecksum = checksumCalculator->getVersion() > 0;
4489
4490         const unsigned int __size_pixels = ((pixels != NULL) ?  glesv2_enc::pixelDataSize3D(self, width, height, depth, format, type, 0) : 0);
4491          unsigned char *ptr;
4492          unsigned char *buf;
4493          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
4494          const size_t checksumSize = checksumCalculator->checksumByteSize();
4495          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4496         buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
4497         ptr = buf;
4498         int tmp = OP_glTexSubImage3DOES;memcpy(ptr, &tmp, 4); ptr += 4;
4499         memcpy(ptr, &totalSize, 4);  ptr += 4;
4500
4501                 memcpy(ptr, &target, 4); ptr += 4;
4502                 memcpy(ptr, &level, 4); ptr += 4;
4503                 memcpy(ptr, &xoffset, 4); ptr += 4;
4504                 memcpy(ptr, &yoffset, 4); ptr += 4;
4505                 memcpy(ptr, &zoffset, 4); ptr += 4;
4506                 memcpy(ptr, &width, 4); ptr += 4;
4507                 memcpy(ptr, &height, 4); ptr += 4;
4508                 memcpy(ptr, &depth, 4); ptr += 4;
4509                 memcpy(ptr, &format, 4); ptr += 4;
4510                 memcpy(ptr, &type, 4); ptr += 4;
4511
4512         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4513         stream->flush();
4514         stream->writeFully(&__size_pixels,4);
4515         if (useChecksum) checksumCalculator->addBuffer(&__size_pixels,4);
4516         if (pixels != NULL) {
4517                 stream->writeFully(pixels, __size_pixels);
4518                 if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
4519         }
4520         buf = stream->alloc(checksumSize);
4521         if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
4522
4523 }
4524
4525 void glCopyTexSubImage3DOES_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
4526 {
4527
4528         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4529         IOStream *stream = ctx->m_stream;
4530         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4531         bool useChecksum = checksumCalculator->getVersion() > 0;
4532
4533          unsigned char *ptr;
4534          unsigned char *buf;
4535          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4;
4536          const size_t checksumSize = checksumCalculator->checksumByteSize();
4537          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4538         buf = stream->alloc(totalSize);
4539         ptr = buf;
4540         int tmp = OP_glCopyTexSubImage3DOES;memcpy(ptr, &tmp, 4); ptr += 4;
4541         memcpy(ptr, &totalSize, 4);  ptr += 4;
4542
4543                 memcpy(ptr, &target, 4); ptr += 4;
4544                 memcpy(ptr, &level, 4); ptr += 4;
4545                 memcpy(ptr, &xoffset, 4); ptr += 4;
4546                 memcpy(ptr, &yoffset, 4); ptr += 4;
4547                 memcpy(ptr, &zoffset, 4); ptr += 4;
4548                 memcpy(ptr, &x, 4); ptr += 4;
4549                 memcpy(ptr, &y, 4); ptr += 4;
4550                 memcpy(ptr, &width, 4); ptr += 4;
4551                 memcpy(ptr, &height, 4); ptr += 4;
4552
4553         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4554         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4555
4556 }
4557
4558 void glCompressedTexImage3DOES_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data)
4559 {
4560
4561         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4562         IOStream *stream = ctx->m_stream;
4563         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4564         bool useChecksum = checksumCalculator->getVersion() > 0;
4565
4566         const unsigned int __size_data = ((data != NULL) ?  imageSize : 0);
4567          unsigned char *ptr;
4568          unsigned char *buf;
4569          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_data + 1*4;
4570          const size_t checksumSize = checksumCalculator->checksumByteSize();
4571          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4572         buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
4573         ptr = buf;
4574         int tmp = OP_glCompressedTexImage3DOES;memcpy(ptr, &tmp, 4); ptr += 4;
4575         memcpy(ptr, &totalSize, 4);  ptr += 4;
4576
4577                 memcpy(ptr, &target, 4); ptr += 4;
4578                 memcpy(ptr, &level, 4); ptr += 4;
4579                 memcpy(ptr, &internalformat, 4); ptr += 4;
4580                 memcpy(ptr, &width, 4); ptr += 4;
4581                 memcpy(ptr, &height, 4); ptr += 4;
4582                 memcpy(ptr, &depth, 4); ptr += 4;
4583                 memcpy(ptr, &border, 4); ptr += 4;
4584                 memcpy(ptr, &imageSize, 4); ptr += 4;
4585
4586         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4587         stream->flush();
4588         stream->writeFully(&__size_data,4);
4589         if (useChecksum) checksumCalculator->addBuffer(&__size_data,4);
4590         if (data != NULL) {
4591                 stream->writeFully(data, __size_data);
4592                 if (useChecksum) checksumCalculator->addBuffer(data, __size_data);
4593         }
4594         buf = stream->alloc(checksumSize);
4595         if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
4596
4597 }
4598
4599 void glCompressedTexSubImage3DOES_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data)
4600 {
4601
4602         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4603         IOStream *stream = ctx->m_stream;
4604         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4605         bool useChecksum = checksumCalculator->getVersion() > 0;
4606
4607         const unsigned int __size_data = ((data != NULL) ?  imageSize : 0);
4608          unsigned char *ptr;
4609          unsigned char *buf;
4610          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_data + 1*4;
4611          const size_t checksumSize = checksumCalculator->checksumByteSize();
4612          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4613         buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
4614         ptr = buf;
4615         int tmp = OP_glCompressedTexSubImage3DOES;memcpy(ptr, &tmp, 4); ptr += 4;
4616         memcpy(ptr, &totalSize, 4);  ptr += 4;
4617
4618                 memcpy(ptr, &target, 4); ptr += 4;
4619                 memcpy(ptr, &level, 4); ptr += 4;
4620                 memcpy(ptr, &xoffset, 4); ptr += 4;
4621                 memcpy(ptr, &yoffset, 4); ptr += 4;
4622                 memcpy(ptr, &zoffset, 4); ptr += 4;
4623                 memcpy(ptr, &width, 4); ptr += 4;
4624                 memcpy(ptr, &height, 4); ptr += 4;
4625                 memcpy(ptr, &depth, 4); ptr += 4;
4626                 memcpy(ptr, &format, 4); ptr += 4;
4627                 memcpy(ptr, &imageSize, 4); ptr += 4;
4628
4629         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4630         stream->flush();
4631         stream->writeFully(&__size_data,4);
4632         if (useChecksum) checksumCalculator->addBuffer(&__size_data,4);
4633         if (data != NULL) {
4634                 stream->writeFully(data, __size_data);
4635                 if (useChecksum) checksumCalculator->addBuffer(data, __size_data);
4636         }
4637         buf = stream->alloc(checksumSize);
4638         if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
4639
4640 }
4641
4642 void glFramebufferTexture3DOES_enc(void *self , GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
4643 {
4644
4645         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4646         IOStream *stream = ctx->m_stream;
4647         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4648         bool useChecksum = checksumCalculator->getVersion() > 0;
4649
4650          unsigned char *ptr;
4651          unsigned char *buf;
4652          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4;
4653          const size_t checksumSize = checksumCalculator->checksumByteSize();
4654          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4655         buf = stream->alloc(totalSize);
4656         ptr = buf;
4657         int tmp = OP_glFramebufferTexture3DOES;memcpy(ptr, &tmp, 4); ptr += 4;
4658         memcpy(ptr, &totalSize, 4);  ptr += 4;
4659
4660                 memcpy(ptr, &target, 4); ptr += 4;
4661                 memcpy(ptr, &attachment, 4); ptr += 4;
4662                 memcpy(ptr, &textarget, 4); ptr += 4;
4663                 memcpy(ptr, &texture, 4); ptr += 4;
4664                 memcpy(ptr, &level, 4); ptr += 4;
4665                 memcpy(ptr, &zoffset, 4); ptr += 4;
4666
4667         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4668         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4669
4670 }
4671
4672 void glBindVertexArrayOES_enc(void *self , GLuint array)
4673 {
4674
4675         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4676         IOStream *stream = ctx->m_stream;
4677         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4678         bool useChecksum = checksumCalculator->getVersion() > 0;
4679
4680          unsigned char *ptr;
4681          unsigned char *buf;
4682          const size_t sizeWithoutChecksum = 8 + 4;
4683          const size_t checksumSize = checksumCalculator->checksumByteSize();
4684          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4685         buf = stream->alloc(totalSize);
4686         ptr = buf;
4687         int tmp = OP_glBindVertexArrayOES;memcpy(ptr, &tmp, 4); ptr += 4;
4688         memcpy(ptr, &totalSize, 4);  ptr += 4;
4689
4690                 memcpy(ptr, &array, 4); ptr += 4;
4691
4692         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4693         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4694
4695 }
4696
4697 void glDeleteVertexArraysOES_enc(void *self , GLsizei n, const GLuint* arrays)
4698 {
4699
4700         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4701         IOStream *stream = ctx->m_stream;
4702         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4703         bool useChecksum = checksumCalculator->getVersion() > 0;
4704
4705         const unsigned int __size_arrays =  (n * sizeof(GLuint));
4706          unsigned char *ptr;
4707          unsigned char *buf;
4708          const size_t sizeWithoutChecksum = 8 + 4 + __size_arrays + 1*4;
4709          const size_t checksumSize = checksumCalculator->checksumByteSize();
4710          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4711         buf = stream->alloc(totalSize);
4712         ptr = buf;
4713         int tmp = OP_glDeleteVertexArraysOES;memcpy(ptr, &tmp, 4); ptr += 4;
4714         memcpy(ptr, &totalSize, 4);  ptr += 4;
4715
4716                 memcpy(ptr, &n, 4); ptr += 4;
4717         *(unsigned int *)(ptr) = __size_arrays; ptr += 4;
4718         memcpy(ptr, arrays, __size_arrays);ptr += __size_arrays;
4719
4720         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4721         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4722
4723 }
4724
4725 void glGenVertexArraysOES_enc(void *self , GLsizei n, GLuint* arrays)
4726 {
4727
4728         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4729         IOStream *stream = ctx->m_stream;
4730         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4731         bool useChecksum = checksumCalculator->getVersion() > 0;
4732
4733         const unsigned int __size_arrays =  (n * sizeof(GLuint));
4734          unsigned char *ptr;
4735          unsigned char *buf;
4736          const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
4737          const size_t checksumSize = checksumCalculator->checksumByteSize();
4738          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4739         buf = stream->alloc(totalSize);
4740         ptr = buf;
4741         int tmp = OP_glGenVertexArraysOES;memcpy(ptr, &tmp, 4); ptr += 4;
4742         memcpy(ptr, &totalSize, 4);  ptr += 4;
4743
4744                 memcpy(ptr, &n, 4); ptr += 4;
4745         *(unsigned int *)(ptr) = __size_arrays; ptr += 4;
4746
4747         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4748         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4749
4750         stream->readback(arrays, __size_arrays);
4751         if (useChecksum) checksumCalculator->addBuffer(arrays, __size_arrays);
4752         if (useChecksum) {
4753                 unsigned char *checksumBufPtr = NULL;
4754                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
4755                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
4756                 stream->readback(checksumBufPtr, checksumSize);
4757                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
4758                         ALOGE("glGenVertexArraysOES: GL communication error, please report this issue to b.android.com.\n");
4759                         abort();
4760                 }
4761         }
4762 }
4763
4764 GLboolean glIsVertexArrayOES_enc(void *self , GLuint array)
4765 {
4766
4767         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4768         IOStream *stream = ctx->m_stream;
4769         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4770         bool useChecksum = checksumCalculator->getVersion() > 0;
4771
4772          unsigned char *ptr;
4773          unsigned char *buf;
4774          const size_t sizeWithoutChecksum = 8 + 4;
4775          const size_t checksumSize = checksumCalculator->checksumByteSize();
4776          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4777         buf = stream->alloc(totalSize);
4778         ptr = buf;
4779         int tmp = OP_glIsVertexArrayOES;memcpy(ptr, &tmp, 4); ptr += 4;
4780         memcpy(ptr, &totalSize, 4);  ptr += 4;
4781
4782                 memcpy(ptr, &array, 4); ptr += 4;
4783
4784         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4785         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4786
4787
4788         GLboolean retval;
4789         stream->readback(&retval, 1);
4790         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
4791         if (useChecksum) {
4792                 unsigned char *checksumBufPtr = NULL;
4793                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
4794                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
4795                 stream->readback(checksumBufPtr, checksumSize);
4796                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
4797                         ALOGE("glIsVertexArrayOES: GL communication error, please report this issue to b.android.com.\n");
4798                         abort();
4799                 }
4800         }
4801         return retval;
4802 }
4803
4804 void glDiscardFramebufferEXT_enc(void *self , GLenum target, GLsizei numAttachments, const GLenum* attachments)
4805 {
4806
4807         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4808         IOStream *stream = ctx->m_stream;
4809         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4810         bool useChecksum = checksumCalculator->getVersion() > 0;
4811
4812         const unsigned int __size_attachments =  (numAttachments * sizeof(GLenum));
4813          unsigned char *ptr;
4814          unsigned char *buf;
4815          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_attachments + 1*4;
4816          const size_t checksumSize = checksumCalculator->checksumByteSize();
4817          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4818         buf = stream->alloc(totalSize);
4819         ptr = buf;
4820         int tmp = OP_glDiscardFramebufferEXT;memcpy(ptr, &tmp, 4); ptr += 4;
4821         memcpy(ptr, &totalSize, 4);  ptr += 4;
4822
4823                 memcpy(ptr, &target, 4); ptr += 4;
4824                 memcpy(ptr, &numAttachments, 4); ptr += 4;
4825         *(unsigned int *)(ptr) = __size_attachments; ptr += 4;
4826         memcpy(ptr, attachments, __size_attachments);ptr += __size_attachments;
4827
4828         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4829         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4830
4831 }
4832
4833 void glVertexAttribPointerData_enc(void *self , GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void* data, GLuint datalen)
4834 {
4835
4836         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4837         IOStream *stream = ctx->m_stream;
4838         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4839         bool useChecksum = checksumCalculator->getVersion() > 0;
4840
4841         const unsigned int __size_data =  datalen;
4842          unsigned char *ptr;
4843          unsigned char *buf;
4844          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 1 + 4 + __size_data + 4 + 1*4;
4845          const size_t checksumSize = checksumCalculator->checksumByteSize();
4846          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4847         buf = stream->alloc(totalSize);
4848         ptr = buf;
4849         int tmp = OP_glVertexAttribPointerData;memcpy(ptr, &tmp, 4); ptr += 4;
4850         memcpy(ptr, &totalSize, 4);  ptr += 4;
4851
4852                 memcpy(ptr, &indx, 4); ptr += 4;
4853                 memcpy(ptr, &size, 4); ptr += 4;
4854                 memcpy(ptr, &type, 4); ptr += 4;
4855                 memcpy(ptr, &normalized, 1); ptr += 1;
4856                 memcpy(ptr, &stride, 4); ptr += 4;
4857         *(unsigned int *)(ptr) = __size_data; ptr += 4;
4858          glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen);ptr += __size_data;
4859                 memcpy(ptr, &datalen, 4); ptr += 4;
4860
4861         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4862         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4863
4864 }
4865
4866 void glVertexAttribPointerOffset_enc(void *self , GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint offset)
4867 {
4868
4869         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4870         IOStream *stream = ctx->m_stream;
4871         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4872         bool useChecksum = checksumCalculator->getVersion() > 0;
4873
4874          unsigned char *ptr;
4875          unsigned char *buf;
4876          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 1 + 4 + 4;
4877          const size_t checksumSize = checksumCalculator->checksumByteSize();
4878          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4879         buf = stream->alloc(totalSize);
4880         ptr = buf;
4881         int tmp = OP_glVertexAttribPointerOffset;memcpy(ptr, &tmp, 4); ptr += 4;
4882         memcpy(ptr, &totalSize, 4);  ptr += 4;
4883
4884                 memcpy(ptr, &indx, 4); ptr += 4;
4885                 memcpy(ptr, &size, 4); ptr += 4;
4886                 memcpy(ptr, &type, 4); ptr += 4;
4887                 memcpy(ptr, &normalized, 1); ptr += 1;
4888                 memcpy(ptr, &stride, 4); ptr += 4;
4889                 memcpy(ptr, &offset, 4); ptr += 4;
4890
4891         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4892         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4893
4894 }
4895
4896 void glDrawElementsOffset_enc(void *self , GLenum mode, GLsizei count, GLenum type, GLuint offset)
4897 {
4898
4899         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4900         IOStream *stream = ctx->m_stream;
4901         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4902         bool useChecksum = checksumCalculator->getVersion() > 0;
4903
4904          unsigned char *ptr;
4905          unsigned char *buf;
4906          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
4907          const size_t checksumSize = checksumCalculator->checksumByteSize();
4908          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4909         buf = stream->alloc(totalSize);
4910         ptr = buf;
4911         int tmp = OP_glDrawElementsOffset;memcpy(ptr, &tmp, 4); ptr += 4;
4912         memcpy(ptr, &totalSize, 4);  ptr += 4;
4913
4914                 memcpy(ptr, &mode, 4); ptr += 4;
4915                 memcpy(ptr, &count, 4); ptr += 4;
4916                 memcpy(ptr, &type, 4); ptr += 4;
4917                 memcpy(ptr, &offset, 4); ptr += 4;
4918
4919         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4920         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4921
4922 }
4923
4924 void glDrawElementsData_enc(void *self , GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen)
4925 {
4926
4927         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4928         IOStream *stream = ctx->m_stream;
4929         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4930         bool useChecksum = checksumCalculator->getVersion() > 0;
4931
4932         const unsigned int __size_data =  datalen;
4933          unsigned char *ptr;
4934          unsigned char *buf;
4935          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_data + 4 + 1*4;
4936          const size_t checksumSize = checksumCalculator->checksumByteSize();
4937          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4938         buf = stream->alloc(totalSize);
4939         ptr = buf;
4940         int tmp = OP_glDrawElementsData;memcpy(ptr, &tmp, 4); ptr += 4;
4941         memcpy(ptr, &totalSize, 4);  ptr += 4;
4942
4943                 memcpy(ptr, &mode, 4); ptr += 4;
4944                 memcpy(ptr, &count, 4); ptr += 4;
4945                 memcpy(ptr, &type, 4); ptr += 4;
4946         *(unsigned int *)(ptr) = __size_data; ptr += 4;
4947         memcpy(ptr, data, __size_data);ptr += __size_data;
4948                 memcpy(ptr, &datalen, 4); ptr += 4;
4949
4950         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4951         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4952
4953 }
4954
4955 void glGetCompressedTextureFormats_enc(void *self , int count, GLint* formats)
4956 {
4957
4958         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4959         IOStream *stream = ctx->m_stream;
4960         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4961         bool useChecksum = checksumCalculator->getVersion() > 0;
4962
4963         const unsigned int __size_formats =  (count * sizeof(GLint));
4964          unsigned char *ptr;
4965          unsigned char *buf;
4966          const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
4967          const size_t checksumSize = checksumCalculator->checksumByteSize();
4968          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4969         buf = stream->alloc(totalSize);
4970         ptr = buf;
4971         int tmp = OP_glGetCompressedTextureFormats;memcpy(ptr, &tmp, 4); ptr += 4;
4972         memcpy(ptr, &totalSize, 4);  ptr += 4;
4973
4974                 memcpy(ptr, &count, 4); ptr += 4;
4975         *(unsigned int *)(ptr) = __size_formats; ptr += 4;
4976
4977         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4978         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4979
4980         stream->readback(formats, __size_formats);
4981         if (useChecksum) checksumCalculator->addBuffer(formats, __size_formats);
4982         if (useChecksum) {
4983                 unsigned char *checksumBufPtr = NULL;
4984                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
4985                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
4986                 stream->readback(checksumBufPtr, checksumSize);
4987                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
4988                         ALOGE("glGetCompressedTextureFormats: GL communication error, please report this issue to b.android.com.\n");
4989                         abort();
4990                 }
4991         }
4992 }
4993
4994 void glShaderString_enc(void *self , GLuint shader, const GLchar* string, GLsizei len)
4995 {
4996
4997         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
4998         IOStream *stream = ctx->m_stream;
4999         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5000         bool useChecksum = checksumCalculator->getVersion() > 0;
5001
5002         const unsigned int __size_string =  len;
5003          unsigned char *ptr;
5004          unsigned char *buf;
5005          const size_t sizeWithoutChecksum = 8 + 4 + __size_string + 4 + 1*4;
5006          const size_t checksumSize = checksumCalculator->checksumByteSize();
5007          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5008         buf = stream->alloc(totalSize);
5009         ptr = buf;
5010         int tmp = OP_glShaderString;memcpy(ptr, &tmp, 4); ptr += 4;
5011         memcpy(ptr, &totalSize, 4);  ptr += 4;
5012
5013                 memcpy(ptr, &shader, 4); ptr += 4;
5014         *(unsigned int *)(ptr) = __size_string; ptr += 4;
5015         memcpy(ptr, string, __size_string);ptr += __size_string;
5016                 memcpy(ptr, &len, 4); ptr += 4;
5017
5018         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5019         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5020
5021 }
5022
5023 int glFinishRoundTrip_enc(void *self )
5024 {
5025
5026         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5027         IOStream *stream = ctx->m_stream;
5028         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5029         bool useChecksum = checksumCalculator->getVersion() > 0;
5030
5031          unsigned char *ptr;
5032          unsigned char *buf;
5033          const size_t sizeWithoutChecksum = 8;
5034          const size_t checksumSize = checksumCalculator->checksumByteSize();
5035          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5036         buf = stream->alloc(totalSize);
5037         ptr = buf;
5038         int tmp = OP_glFinishRoundTrip;memcpy(ptr, &tmp, 4); ptr += 4;
5039         memcpy(ptr, &totalSize, 4);  ptr += 4;
5040
5041
5042         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5043         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5044
5045
5046         int retval;
5047         stream->readback(&retval, 4);
5048         if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
5049         if (useChecksum) {
5050                 unsigned char *checksumBufPtr = NULL;
5051                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
5052                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
5053                 stream->readback(checksumBufPtr, checksumSize);
5054                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
5055                         ALOGE("glFinishRoundTrip: GL communication error, please report this issue to b.android.com.\n");
5056                         abort();
5057                 }
5058         }
5059         return retval;
5060 }
5061
5062 void glGenVertexArrays_enc(void *self , GLsizei n, GLuint* arrays)
5063 {
5064
5065         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5066         IOStream *stream = ctx->m_stream;
5067         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5068         bool useChecksum = checksumCalculator->getVersion() > 0;
5069
5070         const unsigned int __size_arrays =  (n * sizeof(GLuint));
5071          unsigned char *ptr;
5072          unsigned char *buf;
5073          const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
5074          const size_t checksumSize = checksumCalculator->checksumByteSize();
5075          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5076         buf = stream->alloc(totalSize);
5077         ptr = buf;
5078         int tmp = OP_glGenVertexArrays;memcpy(ptr, &tmp, 4); ptr += 4;
5079         memcpy(ptr, &totalSize, 4);  ptr += 4;
5080
5081                 memcpy(ptr, &n, 4); ptr += 4;
5082         *(unsigned int *)(ptr) = __size_arrays; ptr += 4;
5083
5084         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5085         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5086
5087         stream->readback(arrays, __size_arrays);
5088         if (useChecksum) checksumCalculator->addBuffer(arrays, __size_arrays);
5089         if (useChecksum) {
5090                 unsigned char *checksumBufPtr = NULL;
5091                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
5092                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
5093                 stream->readback(checksumBufPtr, checksumSize);
5094                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
5095                         ALOGE("glGenVertexArrays: GL communication error, please report this issue to b.android.com.\n");
5096                         abort();
5097                 }
5098         }
5099 }
5100
5101 void glBindVertexArray_enc(void *self , GLuint array)
5102 {
5103
5104         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5105         IOStream *stream = ctx->m_stream;
5106         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5107         bool useChecksum = checksumCalculator->getVersion() > 0;
5108
5109          unsigned char *ptr;
5110          unsigned char *buf;
5111          const size_t sizeWithoutChecksum = 8 + 4;
5112          const size_t checksumSize = checksumCalculator->checksumByteSize();
5113          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5114         buf = stream->alloc(totalSize);
5115         ptr = buf;
5116         int tmp = OP_glBindVertexArray;memcpy(ptr, &tmp, 4); ptr += 4;
5117         memcpy(ptr, &totalSize, 4);  ptr += 4;
5118
5119                 memcpy(ptr, &array, 4); ptr += 4;
5120
5121         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5122         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5123
5124 }
5125
5126 void glDeleteVertexArrays_enc(void *self , GLsizei n, const GLuint* arrays)
5127 {
5128
5129         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5130         IOStream *stream = ctx->m_stream;
5131         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5132         bool useChecksum = checksumCalculator->getVersion() > 0;
5133
5134         const unsigned int __size_arrays =  (n * sizeof(GLuint));
5135          unsigned char *ptr;
5136          unsigned char *buf;
5137          const size_t sizeWithoutChecksum = 8 + 4 + __size_arrays + 1*4;
5138          const size_t checksumSize = checksumCalculator->checksumByteSize();
5139          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5140         buf = stream->alloc(totalSize);
5141         ptr = buf;
5142         int tmp = OP_glDeleteVertexArrays;memcpy(ptr, &tmp, 4); ptr += 4;
5143         memcpy(ptr, &totalSize, 4);  ptr += 4;
5144
5145                 memcpy(ptr, &n, 4); ptr += 4;
5146         *(unsigned int *)(ptr) = __size_arrays; ptr += 4;
5147         memcpy(ptr, arrays, __size_arrays);ptr += __size_arrays;
5148
5149         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5150         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5151
5152 }
5153
5154 GLboolean glIsVertexArray_enc(void *self , GLuint array)
5155 {
5156
5157         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5158         IOStream *stream = ctx->m_stream;
5159         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5160         bool useChecksum = checksumCalculator->getVersion() > 0;
5161
5162          unsigned char *ptr;
5163          unsigned char *buf;
5164          const size_t sizeWithoutChecksum = 8 + 4;
5165          const size_t checksumSize = checksumCalculator->checksumByteSize();
5166          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5167         buf = stream->alloc(totalSize);
5168         ptr = buf;
5169         int tmp = OP_glIsVertexArray;memcpy(ptr, &tmp, 4); ptr += 4;
5170         memcpy(ptr, &totalSize, 4);  ptr += 4;
5171
5172                 memcpy(ptr, &array, 4); ptr += 4;
5173
5174         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5175         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5176
5177
5178         GLboolean retval;
5179         stream->readback(&retval, 1);
5180         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
5181         if (useChecksum) {
5182                 unsigned char *checksumBufPtr = NULL;
5183                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
5184                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
5185                 stream->readback(checksumBufPtr, checksumSize);
5186                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
5187                         ALOGE("glIsVertexArray: GL communication error, please report this issue to b.android.com.\n");
5188                         abort();
5189                 }
5190         }
5191         return retval;
5192 }
5193
5194 void glMapBufferRangeAEMU_enc(void *self , GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void* mapped)
5195 {
5196
5197         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5198         IOStream *stream = ctx->m_stream;
5199         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5200         bool useChecksum = checksumCalculator->getVersion() > 0;
5201
5202         const unsigned int __size_mapped = ((mapped != NULL) ?  length : 0);
5203          unsigned char *ptr;
5204          unsigned char *buf;
5205          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 0 + 1*4;
5206          const size_t checksumSize = checksumCalculator->checksumByteSize();
5207          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5208         buf = stream->alloc(totalSize);
5209         ptr = buf;
5210         int tmp = OP_glMapBufferRangeAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
5211         memcpy(ptr, &totalSize, 4);  ptr += 4;
5212
5213                 memcpy(ptr, &target, 4); ptr += 4;
5214                 memcpy(ptr, &offset, 4); ptr += 4;
5215                 memcpy(ptr, &length, 4); ptr += 4;
5216                 memcpy(ptr, &access, 4); ptr += 4;
5217         *(unsigned int *)(ptr) = __size_mapped; ptr += 4;
5218
5219         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5220         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5221
5222         if (mapped != NULL) {
5223                 stream->readback(mapped, __size_mapped);
5224                 if (useChecksum) checksumCalculator->addBuffer(mapped, __size_mapped);
5225         }
5226         if (useChecksum) {
5227                 unsigned char *checksumBufPtr = NULL;
5228                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
5229                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
5230                 stream->readback(checksumBufPtr, checksumSize);
5231                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
5232                         ALOGE("glMapBufferRangeAEMU: GL communication error, please report this issue to b.android.com.\n");
5233                         abort();
5234                 }
5235         }
5236 }
5237
5238 void glUnmapBufferAEMU_enc(void *self , GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void* guest_buffer, GLboolean* out_res)
5239 {
5240
5241         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5242         IOStream *stream = ctx->m_stream;
5243         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5244         bool useChecksum = checksumCalculator->getVersion() > 0;
5245
5246         const unsigned int __size_guest_buffer = ((guest_buffer != NULL) ?  length : 0);
5247         const unsigned int __size_out_res =  (sizeof(GLboolean));
5248          unsigned char *ptr;
5249          unsigned char *buf;
5250          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + __size_guest_buffer + 0 + 2*4;
5251          const size_t checksumSize = checksumCalculator->checksumByteSize();
5252          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5253         buf = stream->alloc(totalSize);
5254         ptr = buf;
5255         int tmp = OP_glUnmapBufferAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
5256         memcpy(ptr, &totalSize, 4);  ptr += 4;
5257
5258                 memcpy(ptr, &target, 4); ptr += 4;
5259                 memcpy(ptr, &offset, 4); ptr += 4;
5260                 memcpy(ptr, &length, 4); ptr += 4;
5261                 memcpy(ptr, &access, 4); ptr += 4;
5262         *(unsigned int *)(ptr) = __size_guest_buffer; ptr += 4;
5263         if (guest_buffer != NULL) memcpy(ptr, guest_buffer, __size_guest_buffer);ptr += __size_guest_buffer;
5264         *(unsigned int *)(ptr) = __size_out_res; ptr += 4;
5265
5266         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5267         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5268
5269         stream->readback(out_res, __size_out_res);
5270         if (useChecksum) checksumCalculator->addBuffer(out_res, __size_out_res);
5271         if (useChecksum) {
5272                 unsigned char *checksumBufPtr = NULL;
5273                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
5274                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
5275                 stream->readback(checksumBufPtr, checksumSize);
5276                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
5277                         ALOGE("glUnmapBufferAEMU: GL communication error, please report this issue to b.android.com.\n");
5278                         abort();
5279                 }
5280         }
5281 }
5282
5283 void glFlushMappedBufferRangeAEMU_enc(void *self , GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void* guest_buffer)
5284 {
5285
5286         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5287         IOStream *stream = ctx->m_stream;
5288         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5289         bool useChecksum = checksumCalculator->getVersion() > 0;
5290
5291         const unsigned int __size_guest_buffer = ((guest_buffer != NULL) ?  length : 0);
5292          unsigned char *ptr;
5293          unsigned char *buf;
5294          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + __size_guest_buffer + 1*4;
5295          const size_t checksumSize = checksumCalculator->checksumByteSize();
5296          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5297         buf = stream->alloc(totalSize);
5298         ptr = buf;
5299         int tmp = OP_glFlushMappedBufferRangeAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
5300         memcpy(ptr, &totalSize, 4);  ptr += 4;
5301
5302                 memcpy(ptr, &target, 4); ptr += 4;
5303                 memcpy(ptr, &offset, 4); ptr += 4;
5304                 memcpy(ptr, &length, 4); ptr += 4;
5305                 memcpy(ptr, &access, 4); ptr += 4;
5306         *(unsigned int *)(ptr) = __size_guest_buffer; ptr += 4;
5307         if (guest_buffer != NULL) memcpy(ptr, guest_buffer, __size_guest_buffer);ptr += __size_guest_buffer;
5308
5309         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5310         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5311
5312 }
5313
5314 void glReadPixelsOffsetAEMU_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLuint offset)
5315 {
5316
5317         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5318         IOStream *stream = ctx->m_stream;
5319         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5320         bool useChecksum = checksumCalculator->getVersion() > 0;
5321
5322          unsigned char *ptr;
5323          unsigned char *buf;
5324          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4;
5325          const size_t checksumSize = checksumCalculator->checksumByteSize();
5326          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5327         buf = stream->alloc(totalSize);
5328         ptr = buf;
5329         int tmp = OP_glReadPixelsOffsetAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
5330         memcpy(ptr, &totalSize, 4);  ptr += 4;
5331
5332                 memcpy(ptr, &x, 4); ptr += 4;
5333                 memcpy(ptr, &y, 4); ptr += 4;
5334                 memcpy(ptr, &width, 4); ptr += 4;
5335                 memcpy(ptr, &height, 4); ptr += 4;
5336                 memcpy(ptr, &format, 4); ptr += 4;
5337                 memcpy(ptr, &type, 4); ptr += 4;
5338                 memcpy(ptr, &offset, 4); ptr += 4;
5339
5340         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5341         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5342
5343 }
5344
5345 void glCompressedTexImage2DOffsetAEMU_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLuint offset)
5346 {
5347
5348         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5349         IOStream *stream = ctx->m_stream;
5350         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5351         bool useChecksum = checksumCalculator->getVersion() > 0;
5352
5353          unsigned char *ptr;
5354          unsigned char *buf;
5355          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4;
5356          const size_t checksumSize = checksumCalculator->checksumByteSize();
5357          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5358         buf = stream->alloc(totalSize);
5359         ptr = buf;
5360         int tmp = OP_glCompressedTexImage2DOffsetAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
5361         memcpy(ptr, &totalSize, 4);  ptr += 4;
5362
5363                 memcpy(ptr, &target, 4); ptr += 4;
5364                 memcpy(ptr, &level, 4); ptr += 4;
5365                 memcpy(ptr, &internalformat, 4); ptr += 4;
5366                 memcpy(ptr, &width, 4); ptr += 4;
5367                 memcpy(ptr, &height, 4); ptr += 4;
5368                 memcpy(ptr, &border, 4); ptr += 4;
5369                 memcpy(ptr, &imageSize, 4); ptr += 4;
5370                 memcpy(ptr, &offset, 4); ptr += 4;
5371
5372         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5373         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5374
5375 }
5376
5377 void glCompressedTexSubImage2DOffsetAEMU_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLuint offset)
5378 {
5379
5380         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5381         IOStream *stream = ctx->m_stream;
5382         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5383         bool useChecksum = checksumCalculator->getVersion() > 0;
5384
5385          unsigned char *ptr;
5386          unsigned char *buf;
5387          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4;
5388          const size_t checksumSize = checksumCalculator->checksumByteSize();
5389          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5390         buf = stream->alloc(totalSize);
5391         ptr = buf;
5392         int tmp = OP_glCompressedTexSubImage2DOffsetAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
5393         memcpy(ptr, &totalSize, 4);  ptr += 4;
5394
5395                 memcpy(ptr, &target, 4); ptr += 4;
5396                 memcpy(ptr, &level, 4); ptr += 4;
5397                 memcpy(ptr, &xoffset, 4); ptr += 4;
5398                 memcpy(ptr, &yoffset, 4); ptr += 4;
5399                 memcpy(ptr, &width, 4); ptr += 4;
5400                 memcpy(ptr, &height, 4); ptr += 4;
5401                 memcpy(ptr, &format, 4); ptr += 4;
5402                 memcpy(ptr, &imageSize, 4); ptr += 4;
5403                 memcpy(ptr, &offset, 4); ptr += 4;
5404
5405         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5406         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5407
5408 }
5409
5410 void glTexImage2DOffsetAEMU_enc(void *self , GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLuint offset)
5411 {
5412
5413         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5414         IOStream *stream = ctx->m_stream;
5415         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5416         bool useChecksum = checksumCalculator->getVersion() > 0;
5417
5418          unsigned char *ptr;
5419          unsigned char *buf;
5420          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4;
5421          const size_t checksumSize = checksumCalculator->checksumByteSize();
5422          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5423         buf = stream->alloc(totalSize);
5424         ptr = buf;
5425         int tmp = OP_glTexImage2DOffsetAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
5426         memcpy(ptr, &totalSize, 4);  ptr += 4;
5427
5428                 memcpy(ptr, &target, 4); ptr += 4;
5429                 memcpy(ptr, &level, 4); ptr += 4;
5430                 memcpy(ptr, &internalformat, 4); ptr += 4;
5431                 memcpy(ptr, &width, 4); ptr += 4;
5432                 memcpy(ptr, &height, 4); ptr += 4;
5433                 memcpy(ptr, &border, 4); ptr += 4;
5434                 memcpy(ptr, &format, 4); ptr += 4;
5435                 memcpy(ptr, &type, 4); ptr += 4;
5436                 memcpy(ptr, &offset, 4); ptr += 4;
5437
5438         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5439         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5440
5441 }
5442
5443 void glTexSubImage2DOffsetAEMU_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLuint offset)
5444 {
5445
5446         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5447         IOStream *stream = ctx->m_stream;
5448         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5449         bool useChecksum = checksumCalculator->getVersion() > 0;
5450
5451          unsigned char *ptr;
5452          unsigned char *buf;
5453          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4;
5454          const size_t checksumSize = checksumCalculator->checksumByteSize();
5455          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5456         buf = stream->alloc(totalSize);
5457         ptr = buf;
5458         int tmp = OP_glTexSubImage2DOffsetAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
5459         memcpy(ptr, &totalSize, 4);  ptr += 4;
5460
5461                 memcpy(ptr, &target, 4); ptr += 4;
5462                 memcpy(ptr, &level, 4); ptr += 4;
5463                 memcpy(ptr, &xoffset, 4); ptr += 4;
5464                 memcpy(ptr, &yoffset, 4); ptr += 4;
5465                 memcpy(ptr, &width, 4); ptr += 4;
5466                 memcpy(ptr, &height, 4); ptr += 4;
5467                 memcpy(ptr, &format, 4); ptr += 4;
5468                 memcpy(ptr, &type, 4); ptr += 4;
5469                 memcpy(ptr, &offset, 4); ptr += 4;
5470
5471         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5472         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5473
5474 }
5475
5476 void glBindBufferRange_enc(void *self , GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
5477 {
5478
5479         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5480         IOStream *stream = ctx->m_stream;
5481         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5482         bool useChecksum = checksumCalculator->getVersion() > 0;
5483
5484          unsigned char *ptr;
5485          unsigned char *buf;
5486          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
5487          const size_t checksumSize = checksumCalculator->checksumByteSize();
5488          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5489         buf = stream->alloc(totalSize);
5490         ptr = buf;
5491         int tmp = OP_glBindBufferRange;memcpy(ptr, &tmp, 4); ptr += 4;
5492         memcpy(ptr, &totalSize, 4);  ptr += 4;
5493
5494                 memcpy(ptr, &target, 4); ptr += 4;
5495                 memcpy(ptr, &index, 4); ptr += 4;
5496                 memcpy(ptr, &buffer, 4); ptr += 4;
5497                 memcpy(ptr, &offset, 4); ptr += 4;
5498                 memcpy(ptr, &size, 4); ptr += 4;
5499
5500         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5501         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5502
5503 }
5504
5505 void glBindBufferBase_enc(void *self , GLenum target, GLuint index, GLuint buffer)
5506 {
5507
5508         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5509         IOStream *stream = ctx->m_stream;
5510         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5511         bool useChecksum = checksumCalculator->getVersion() > 0;
5512
5513          unsigned char *ptr;
5514          unsigned char *buf;
5515          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
5516          const size_t checksumSize = checksumCalculator->checksumByteSize();
5517          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5518         buf = stream->alloc(totalSize);
5519         ptr = buf;
5520         int tmp = OP_glBindBufferBase;memcpy(ptr, &tmp, 4); ptr += 4;
5521         memcpy(ptr, &totalSize, 4);  ptr += 4;
5522
5523                 memcpy(ptr, &target, 4); ptr += 4;
5524                 memcpy(ptr, &index, 4); ptr += 4;
5525                 memcpy(ptr, &buffer, 4); ptr += 4;
5526
5527         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5528         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5529
5530 }
5531
5532 void glCopyBufferSubData_enc(void *self , GLenum readtarget, GLenum writetarget, GLintptr readoffset, GLintptr writeoffset, GLsizeiptr size)
5533 {
5534
5535         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5536         IOStream *stream = ctx->m_stream;
5537         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5538         bool useChecksum = checksumCalculator->getVersion() > 0;
5539
5540          unsigned char *ptr;
5541          unsigned char *buf;
5542          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
5543          const size_t checksumSize = checksumCalculator->checksumByteSize();
5544          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5545         buf = stream->alloc(totalSize);
5546         ptr = buf;
5547         int tmp = OP_glCopyBufferSubData;memcpy(ptr, &tmp, 4); ptr += 4;
5548         memcpy(ptr, &totalSize, 4);  ptr += 4;
5549
5550                 memcpy(ptr, &readtarget, 4); ptr += 4;
5551                 memcpy(ptr, &writetarget, 4); ptr += 4;
5552                 memcpy(ptr, &readoffset, 4); ptr += 4;
5553                 memcpy(ptr, &writeoffset, 4); ptr += 4;
5554                 memcpy(ptr, &size, 4); ptr += 4;
5555
5556         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5557         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5558
5559         stream->flush();
5560 }
5561
5562 void glClearBufferiv_enc(void *self , GLenum buffer, GLint drawBuffer, const GLint* value)
5563 {
5564
5565         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5566         IOStream *stream = ctx->m_stream;
5567         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5568         bool useChecksum = checksumCalculator->getVersion() > 0;
5569
5570         const unsigned int __size_value =  (sizeof(GLint) * glesv2_enc::clearBufferNumElts(self, buffer));
5571          unsigned char *ptr;
5572          unsigned char *buf;
5573          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_value + 1*4;
5574          const size_t checksumSize = checksumCalculator->checksumByteSize();
5575          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5576         buf = stream->alloc(totalSize);
5577         ptr = buf;
5578         int tmp = OP_glClearBufferiv;memcpy(ptr, &tmp, 4); ptr += 4;
5579         memcpy(ptr, &totalSize, 4);  ptr += 4;
5580
5581                 memcpy(ptr, &buffer, 4); ptr += 4;
5582                 memcpy(ptr, &drawBuffer, 4); ptr += 4;
5583         *(unsigned int *)(ptr) = __size_value; ptr += 4;
5584         memcpy(ptr, value, __size_value);ptr += __size_value;
5585
5586         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5587         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5588
5589 }
5590
5591 void glClearBufferuiv_enc(void *self , GLenum buffer, GLint drawBuffer, const GLuint* value)
5592 {
5593
5594         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5595         IOStream *stream = ctx->m_stream;
5596         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5597         bool useChecksum = checksumCalculator->getVersion() > 0;
5598
5599         const unsigned int __size_value =  (sizeof(GLuint) * glesv2_enc::clearBufferNumElts(self, buffer));
5600          unsigned char *ptr;
5601          unsigned char *buf;
5602          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_value + 1*4;
5603          const size_t checksumSize = checksumCalculator->checksumByteSize();
5604          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5605         buf = stream->alloc(totalSize);
5606         ptr = buf;
5607         int tmp = OP_glClearBufferuiv;memcpy(ptr, &tmp, 4); ptr += 4;
5608         memcpy(ptr, &totalSize, 4);  ptr += 4;
5609
5610                 memcpy(ptr, &buffer, 4); ptr += 4;
5611                 memcpy(ptr, &drawBuffer, 4); ptr += 4;
5612         *(unsigned int *)(ptr) = __size_value; ptr += 4;
5613         memcpy(ptr, value, __size_value);ptr += __size_value;
5614
5615         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5616         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5617
5618 }
5619
5620 void glClearBufferfv_enc(void *self , GLenum buffer, GLint drawBuffer, const GLfloat* value)
5621 {
5622
5623         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5624         IOStream *stream = ctx->m_stream;
5625         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5626         bool useChecksum = checksumCalculator->getVersion() > 0;
5627
5628         const unsigned int __size_value =  (sizeof(GLfloat) * glesv2_enc::clearBufferNumElts(self, buffer));
5629          unsigned char *ptr;
5630          unsigned char *buf;
5631          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_value + 1*4;
5632          const size_t checksumSize = checksumCalculator->checksumByteSize();
5633          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5634         buf = stream->alloc(totalSize);
5635         ptr = buf;
5636         int tmp = OP_glClearBufferfv;memcpy(ptr, &tmp, 4); ptr += 4;
5637         memcpy(ptr, &totalSize, 4);  ptr += 4;
5638
5639                 memcpy(ptr, &buffer, 4); ptr += 4;
5640                 memcpy(ptr, &drawBuffer, 4); ptr += 4;
5641         *(unsigned int *)(ptr) = __size_value; ptr += 4;
5642         memcpy(ptr, value, __size_value);ptr += __size_value;
5643
5644         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5645         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5646
5647 }
5648
5649 void glClearBufferfi_enc(void *self , GLenum buffer, GLint drawBuffer, GLfloat depth, GLint stencil)
5650 {
5651
5652         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5653         IOStream *stream = ctx->m_stream;
5654         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5655         bool useChecksum = checksumCalculator->getVersion() > 0;
5656
5657          unsigned char *ptr;
5658          unsigned char *buf;
5659          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
5660          const size_t checksumSize = checksumCalculator->checksumByteSize();
5661          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5662         buf = stream->alloc(totalSize);
5663         ptr = buf;
5664         int tmp = OP_glClearBufferfi;memcpy(ptr, &tmp, 4); ptr += 4;
5665         memcpy(ptr, &totalSize, 4);  ptr += 4;
5666
5667                 memcpy(ptr, &buffer, 4); ptr += 4;
5668                 memcpy(ptr, &drawBuffer, 4); ptr += 4;
5669                 memcpy(ptr, &depth, 4); ptr += 4;
5670                 memcpy(ptr, &stencil, 4); ptr += 4;
5671
5672         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5673         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5674
5675 }
5676
5677 void glUniformBlockBinding_enc(void *self , GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
5678 {
5679
5680         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5681         IOStream *stream = ctx->m_stream;
5682         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5683         bool useChecksum = checksumCalculator->getVersion() > 0;
5684
5685          unsigned char *ptr;
5686          unsigned char *buf;
5687          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
5688          const size_t checksumSize = checksumCalculator->checksumByteSize();
5689          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5690         buf = stream->alloc(totalSize);
5691         ptr = buf;
5692         int tmp = OP_glUniformBlockBinding;memcpy(ptr, &tmp, 4); ptr += 4;
5693         memcpy(ptr, &totalSize, 4);  ptr += 4;
5694
5695                 memcpy(ptr, &program, 4); ptr += 4;
5696                 memcpy(ptr, &uniformBlockIndex, 4); ptr += 4;
5697                 memcpy(ptr, &uniformBlockBinding, 4); ptr += 4;
5698
5699         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5700         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5701
5702 }
5703
5704 GLuint glGetUniformBlockIndex_enc(void *self , GLuint program, const GLchar* uniformBlockName)
5705 {
5706
5707         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5708         IOStream *stream = ctx->m_stream;
5709         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5710         bool useChecksum = checksumCalculator->getVersion() > 0;
5711
5712         const unsigned int __size_uniformBlockName =  (strlen(uniformBlockName) + 1);
5713          unsigned char *ptr;
5714          unsigned char *buf;
5715          const size_t sizeWithoutChecksum = 8 + 4 + __size_uniformBlockName + 1*4;
5716          const size_t checksumSize = checksumCalculator->checksumByteSize();
5717          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5718         buf = stream->alloc(totalSize);
5719         ptr = buf;
5720         int tmp = OP_glGetUniformBlockIndex;memcpy(ptr, &tmp, 4); ptr += 4;
5721         memcpy(ptr, &totalSize, 4);  ptr += 4;
5722
5723                 memcpy(ptr, &program, 4); ptr += 4;
5724         *(unsigned int *)(ptr) = __size_uniformBlockName; ptr += 4;
5725         memcpy(ptr, uniformBlockName, __size_uniformBlockName);ptr += __size_uniformBlockName;
5726
5727         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5728         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5729
5730
5731         GLuint retval;
5732         stream->readback(&retval, 4);
5733         if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
5734         if (useChecksum) {
5735                 unsigned char *checksumBufPtr = NULL;
5736                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
5737                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
5738                 stream->readback(checksumBufPtr, checksumSize);
5739                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
5740                         ALOGE("glGetUniformBlockIndex: GL communication error, please report this issue to b.android.com.\n");
5741                         abort();
5742                 }
5743         }
5744         return retval;
5745 }
5746
5747 void glGetUniformIndicesAEMU_enc(void *self , GLuint program, GLsizei uniformCount, const GLchar* packedUniformNames, GLsizei packedLen, GLuint* uniformIndices)
5748 {
5749
5750         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5751         IOStream *stream = ctx->m_stream;
5752         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5753         bool useChecksum = checksumCalculator->getVersion() > 0;
5754
5755         const unsigned int __size_packedUniformNames =  packedLen;
5756         const unsigned int __size_uniformIndices =  (uniformCount * sizeof(GLuint));
5757          unsigned char *ptr;
5758          unsigned char *buf;
5759          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_packedUniformNames + 4 + 0 + 2*4;
5760          const size_t checksumSize = checksumCalculator->checksumByteSize();
5761          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5762         buf = stream->alloc(totalSize);
5763         ptr = buf;
5764         int tmp = OP_glGetUniformIndicesAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
5765         memcpy(ptr, &totalSize, 4);  ptr += 4;
5766
5767                 memcpy(ptr, &program, 4); ptr += 4;
5768                 memcpy(ptr, &uniformCount, 4); ptr += 4;
5769         *(unsigned int *)(ptr) = __size_packedUniformNames; ptr += 4;
5770         memcpy(ptr, packedUniformNames, __size_packedUniformNames);ptr += __size_packedUniformNames;
5771                 memcpy(ptr, &packedLen, 4); ptr += 4;
5772         *(unsigned int *)(ptr) = __size_uniformIndices; ptr += 4;
5773
5774         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5775         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5776
5777         stream->readback(uniformIndices, __size_uniformIndices);
5778         if (useChecksum) checksumCalculator->addBuffer(uniformIndices, __size_uniformIndices);
5779         if (useChecksum) {
5780                 unsigned char *checksumBufPtr = NULL;
5781                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
5782                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
5783                 stream->readback(checksumBufPtr, checksumSize);
5784                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
5785                         ALOGE("glGetUniformIndicesAEMU: GL communication error, please report this issue to b.android.com.\n");
5786                         abort();
5787                 }
5788         }
5789 }
5790
5791 void glGetActiveUniformBlockiv_enc(void *self , GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params)
5792 {
5793
5794         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5795         IOStream *stream = ctx->m_stream;
5796         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5797         bool useChecksum = checksumCalculator->getVersion() > 0;
5798
5799         const unsigned int __size_params =  (glesv2_enc::glActiveUniformBlockivParamSize(self, program, uniformBlockIndex, pname) * sizeof(GLint));
5800          unsigned char *ptr;
5801          unsigned char *buf;
5802          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 0 + 1*4;
5803          const size_t checksumSize = checksumCalculator->checksumByteSize();
5804          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5805         buf = stream->alloc(totalSize);
5806         ptr = buf;
5807         int tmp = OP_glGetActiveUniformBlockiv;memcpy(ptr, &tmp, 4); ptr += 4;
5808         memcpy(ptr, &totalSize, 4);  ptr += 4;
5809
5810                 memcpy(ptr, &program, 4); ptr += 4;
5811                 memcpy(ptr, &uniformBlockIndex, 4); ptr += 4;
5812                 memcpy(ptr, &pname, 4); ptr += 4;
5813         *(unsigned int *)(ptr) = __size_params; ptr += 4;
5814
5815         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5816         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5817
5818         stream->readback(params, __size_params);
5819         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
5820         if (useChecksum) {
5821                 unsigned char *checksumBufPtr = NULL;
5822                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
5823                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
5824                 stream->readback(checksumBufPtr, checksumSize);
5825                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
5826                         ALOGE("glGetActiveUniformBlockiv: GL communication error, please report this issue to b.android.com.\n");
5827                         abort();
5828                 }
5829         }
5830 }
5831
5832 void glGetActiveUniformBlockName_enc(void *self , GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName)
5833 {
5834
5835         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5836         IOStream *stream = ctx->m_stream;
5837         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5838         bool useChecksum = checksumCalculator->getVersion() > 0;
5839
5840         const unsigned int __size_length = ((length != NULL) ?  (sizeof(GLsizei)) : 0);
5841         const unsigned int __size_uniformBlockName = ((uniformBlockName != NULL) ?  bufSize : 0);
5842          unsigned char *ptr;
5843          unsigned char *buf;
5844          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 0 + 0 + 2*4;
5845          const size_t checksumSize = checksumCalculator->checksumByteSize();
5846          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5847         buf = stream->alloc(totalSize);
5848         ptr = buf;
5849         int tmp = OP_glGetActiveUniformBlockName;memcpy(ptr, &tmp, 4); ptr += 4;
5850         memcpy(ptr, &totalSize, 4);  ptr += 4;
5851
5852                 memcpy(ptr, &program, 4); ptr += 4;
5853                 memcpy(ptr, &uniformBlockIndex, 4); ptr += 4;
5854                 memcpy(ptr, &bufSize, 4); ptr += 4;
5855         *(unsigned int *)(ptr) = __size_length; ptr += 4;
5856         *(unsigned int *)(ptr) = __size_uniformBlockName; ptr += 4;
5857
5858         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5859         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5860
5861         if (length != NULL) {
5862                 stream->readback(length, __size_length);
5863                 if (useChecksum) checksumCalculator->addBuffer(length, __size_length);
5864         }
5865         if (uniformBlockName != NULL) {
5866                 stream->readback(uniformBlockName, __size_uniformBlockName);
5867                 if (useChecksum) checksumCalculator->addBuffer(uniformBlockName, __size_uniformBlockName);
5868         }
5869         if (useChecksum) {
5870                 unsigned char *checksumBufPtr = NULL;
5871                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
5872                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
5873                 stream->readback(checksumBufPtr, checksumSize);
5874                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
5875                         ALOGE("glGetActiveUniformBlockName: GL communication error, please report this issue to b.android.com.\n");
5876                         abort();
5877                 }
5878         }
5879 }
5880
5881 void glUniform1ui_enc(void *self , GLint location, GLuint v0)
5882 {
5883
5884         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5885         IOStream *stream = ctx->m_stream;
5886         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5887         bool useChecksum = checksumCalculator->getVersion() > 0;
5888
5889          unsigned char *ptr;
5890          unsigned char *buf;
5891          const size_t sizeWithoutChecksum = 8 + 4 + 4;
5892          const size_t checksumSize = checksumCalculator->checksumByteSize();
5893          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5894         buf = stream->alloc(totalSize);
5895         ptr = buf;
5896         int tmp = OP_glUniform1ui;memcpy(ptr, &tmp, 4); ptr += 4;
5897         memcpy(ptr, &totalSize, 4);  ptr += 4;
5898
5899                 memcpy(ptr, &location, 4); ptr += 4;
5900                 memcpy(ptr, &v0, 4); ptr += 4;
5901
5902         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5903         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5904
5905 }
5906
5907 void glUniform2ui_enc(void *self , GLint location, GLuint v0, GLuint v1)
5908 {
5909
5910         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5911         IOStream *stream = ctx->m_stream;
5912         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5913         bool useChecksum = checksumCalculator->getVersion() > 0;
5914
5915          unsigned char *ptr;
5916          unsigned char *buf;
5917          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
5918          const size_t checksumSize = checksumCalculator->checksumByteSize();
5919          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5920         buf = stream->alloc(totalSize);
5921         ptr = buf;
5922         int tmp = OP_glUniform2ui;memcpy(ptr, &tmp, 4); ptr += 4;
5923         memcpy(ptr, &totalSize, 4);  ptr += 4;
5924
5925                 memcpy(ptr, &location, 4); ptr += 4;
5926                 memcpy(ptr, &v0, 4); ptr += 4;
5927                 memcpy(ptr, &v1, 4); ptr += 4;
5928
5929         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5930         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5931
5932 }
5933
5934 void glUniform3ui_enc(void *self , GLint location, GLuint v0, GLuint v1, GLuint v2)
5935 {
5936
5937         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5938         IOStream *stream = ctx->m_stream;
5939         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5940         bool useChecksum = checksumCalculator->getVersion() > 0;
5941
5942          unsigned char *ptr;
5943          unsigned char *buf;
5944          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
5945          const size_t checksumSize = checksumCalculator->checksumByteSize();
5946          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5947         buf = stream->alloc(totalSize);
5948         ptr = buf;
5949         int tmp = OP_glUniform3ui;memcpy(ptr, &tmp, 4); ptr += 4;
5950         memcpy(ptr, &totalSize, 4);  ptr += 4;
5951
5952                 memcpy(ptr, &location, 4); ptr += 4;
5953                 memcpy(ptr, &v0, 4); ptr += 4;
5954                 memcpy(ptr, &v1, 4); ptr += 4;
5955                 memcpy(ptr, &v2, 4); ptr += 4;
5956
5957         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5958         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5959
5960 }
5961
5962 void glUniform4ui_enc(void *self , GLint location, GLint v0, GLuint v1, GLuint v2, GLuint v3)
5963 {
5964
5965         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5966         IOStream *stream = ctx->m_stream;
5967         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5968         bool useChecksum = checksumCalculator->getVersion() > 0;
5969
5970          unsigned char *ptr;
5971          unsigned char *buf;
5972          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
5973          const size_t checksumSize = checksumCalculator->checksumByteSize();
5974          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5975         buf = stream->alloc(totalSize);
5976         ptr = buf;
5977         int tmp = OP_glUniform4ui;memcpy(ptr, &tmp, 4); ptr += 4;
5978         memcpy(ptr, &totalSize, 4);  ptr += 4;
5979
5980                 memcpy(ptr, &location, 4); ptr += 4;
5981                 memcpy(ptr, &v0, 4); ptr += 4;
5982                 memcpy(ptr, &v1, 4); ptr += 4;
5983                 memcpy(ptr, &v2, 4); ptr += 4;
5984                 memcpy(ptr, &v3, 4); ptr += 4;
5985
5986         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5987         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5988
5989 }
5990
5991 void glUniform1uiv_enc(void *self , GLint location, GLsizei count, const GLuint* value)
5992 {
5993
5994         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
5995         IOStream *stream = ctx->m_stream;
5996         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5997         bool useChecksum = checksumCalculator->getVersion() > 0;
5998
5999         const unsigned int __size_value =  (count * sizeof(GLuint));
6000          unsigned char *ptr;
6001          unsigned char *buf;
6002          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_value + 1*4;
6003          const size_t checksumSize = checksumCalculator->checksumByteSize();
6004          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6005         buf = stream->alloc(totalSize);
6006         ptr = buf;
6007         int tmp = OP_glUniform1uiv;memcpy(ptr, &tmp, 4); ptr += 4;
6008         memcpy(ptr, &totalSize, 4);  ptr += 4;
6009
6010                 memcpy(ptr, &location, 4); ptr += 4;
6011                 memcpy(ptr, &count, 4); ptr += 4;
6012         *(unsigned int *)(ptr) = __size_value; ptr += 4;
6013         memcpy(ptr, value, __size_value);ptr += __size_value;
6014
6015         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6016         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6017
6018 }
6019
6020 void glUniform2uiv_enc(void *self , GLint location, GLsizei count, const GLuint* value)
6021 {
6022
6023         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6024         IOStream *stream = ctx->m_stream;
6025         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6026         bool useChecksum = checksumCalculator->getVersion() > 0;
6027
6028         const unsigned int __size_value =  (count * 2 * sizeof(GLuint));
6029          unsigned char *ptr;
6030          unsigned char *buf;
6031          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_value + 1*4;
6032          const size_t checksumSize = checksumCalculator->checksumByteSize();
6033          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6034         buf = stream->alloc(totalSize);
6035         ptr = buf;
6036         int tmp = OP_glUniform2uiv;memcpy(ptr, &tmp, 4); ptr += 4;
6037         memcpy(ptr, &totalSize, 4);  ptr += 4;
6038
6039                 memcpy(ptr, &location, 4); ptr += 4;
6040                 memcpy(ptr, &count, 4); ptr += 4;
6041         *(unsigned int *)(ptr) = __size_value; ptr += 4;
6042         memcpy(ptr, value, __size_value);ptr += __size_value;
6043
6044         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6045         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6046
6047 }
6048
6049 void glUniform3uiv_enc(void *self , GLint location, GLsizei count, const GLuint* value)
6050 {
6051
6052         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6053         IOStream *stream = ctx->m_stream;
6054         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6055         bool useChecksum = checksumCalculator->getVersion() > 0;
6056
6057         const unsigned int __size_value =  (count * 3 * sizeof(GLuint));
6058          unsigned char *ptr;
6059          unsigned char *buf;
6060          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_value + 1*4;
6061          const size_t checksumSize = checksumCalculator->checksumByteSize();
6062          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6063         buf = stream->alloc(totalSize);
6064         ptr = buf;
6065         int tmp = OP_glUniform3uiv;memcpy(ptr, &tmp, 4); ptr += 4;
6066         memcpy(ptr, &totalSize, 4);  ptr += 4;
6067
6068                 memcpy(ptr, &location, 4); ptr += 4;
6069                 memcpy(ptr, &count, 4); ptr += 4;
6070         *(unsigned int *)(ptr) = __size_value; ptr += 4;
6071         memcpy(ptr, value, __size_value);ptr += __size_value;
6072
6073         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6074         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6075
6076 }
6077
6078 void glUniform4uiv_enc(void *self , GLint location, GLsizei count, const GLuint* value)
6079 {
6080
6081         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6082         IOStream *stream = ctx->m_stream;
6083         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6084         bool useChecksum = checksumCalculator->getVersion() > 0;
6085
6086         const unsigned int __size_value =  (count * 4 * sizeof(GLuint));
6087          unsigned char *ptr;
6088          unsigned char *buf;
6089          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_value + 1*4;
6090          const size_t checksumSize = checksumCalculator->checksumByteSize();
6091          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6092         buf = stream->alloc(totalSize);
6093         ptr = buf;
6094         int tmp = OP_glUniform4uiv;memcpy(ptr, &tmp, 4); ptr += 4;
6095         memcpy(ptr, &totalSize, 4);  ptr += 4;
6096
6097                 memcpy(ptr, &location, 4); ptr += 4;
6098                 memcpy(ptr, &count, 4); ptr += 4;
6099         *(unsigned int *)(ptr) = __size_value; ptr += 4;
6100         memcpy(ptr, value, __size_value);ptr += __size_value;
6101
6102         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6103         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6104
6105 }
6106
6107 void glUniformMatrix2x3fv_enc(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
6108 {
6109
6110         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6111         IOStream *stream = ctx->m_stream;
6112         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6113         bool useChecksum = checksumCalculator->getVersion() > 0;
6114
6115         const unsigned int __size_value =  (count * 6 * sizeof(GLfloat));
6116          unsigned char *ptr;
6117          unsigned char *buf;
6118          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 1 + __size_value + 1*4;
6119          const size_t checksumSize = checksumCalculator->checksumByteSize();
6120          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6121         buf = stream->alloc(totalSize);
6122         ptr = buf;
6123         int tmp = OP_glUniformMatrix2x3fv;memcpy(ptr, &tmp, 4); ptr += 4;
6124         memcpy(ptr, &totalSize, 4);  ptr += 4;
6125
6126                 memcpy(ptr, &location, 4); ptr += 4;
6127                 memcpy(ptr, &count, 4); ptr += 4;
6128                 memcpy(ptr, &transpose, 1); ptr += 1;
6129         *(unsigned int *)(ptr) = __size_value; ptr += 4;
6130         memcpy(ptr, value, __size_value);ptr += __size_value;
6131
6132         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6133         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6134
6135 }
6136
6137 void glUniformMatrix3x2fv_enc(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
6138 {
6139
6140         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6141         IOStream *stream = ctx->m_stream;
6142         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6143         bool useChecksum = checksumCalculator->getVersion() > 0;
6144
6145         const unsigned int __size_value =  (count * 6 * sizeof(GLfloat));
6146          unsigned char *ptr;
6147          unsigned char *buf;
6148          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 1 + __size_value + 1*4;
6149          const size_t checksumSize = checksumCalculator->checksumByteSize();
6150          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6151         buf = stream->alloc(totalSize);
6152         ptr = buf;
6153         int tmp = OP_glUniformMatrix3x2fv;memcpy(ptr, &tmp, 4); ptr += 4;
6154         memcpy(ptr, &totalSize, 4);  ptr += 4;
6155
6156                 memcpy(ptr, &location, 4); ptr += 4;
6157                 memcpy(ptr, &count, 4); ptr += 4;
6158                 memcpy(ptr, &transpose, 1); ptr += 1;
6159         *(unsigned int *)(ptr) = __size_value; ptr += 4;
6160         memcpy(ptr, value, __size_value);ptr += __size_value;
6161
6162         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6163         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6164
6165 }
6166
6167 void glUniformMatrix2x4fv_enc(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
6168 {
6169
6170         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6171         IOStream *stream = ctx->m_stream;
6172         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6173         bool useChecksum = checksumCalculator->getVersion() > 0;
6174
6175         const unsigned int __size_value =  (count * 8 * sizeof(GLfloat));
6176          unsigned char *ptr;
6177          unsigned char *buf;
6178          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 1 + __size_value + 1*4;
6179          const size_t checksumSize = checksumCalculator->checksumByteSize();
6180          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6181         buf = stream->alloc(totalSize);
6182         ptr = buf;
6183         int tmp = OP_glUniformMatrix2x4fv;memcpy(ptr, &tmp, 4); ptr += 4;
6184         memcpy(ptr, &totalSize, 4);  ptr += 4;
6185
6186                 memcpy(ptr, &location, 4); ptr += 4;
6187                 memcpy(ptr, &count, 4); ptr += 4;
6188                 memcpy(ptr, &transpose, 1); ptr += 1;
6189         *(unsigned int *)(ptr) = __size_value; ptr += 4;
6190         memcpy(ptr, value, __size_value);ptr += __size_value;
6191
6192         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6193         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6194
6195 }
6196
6197 void glUniformMatrix4x2fv_enc(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
6198 {
6199
6200         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6201         IOStream *stream = ctx->m_stream;
6202         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6203         bool useChecksum = checksumCalculator->getVersion() > 0;
6204
6205         const unsigned int __size_value =  (count * 8 * sizeof(GLfloat));
6206          unsigned char *ptr;
6207          unsigned char *buf;
6208          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 1 + __size_value + 1*4;
6209          const size_t checksumSize = checksumCalculator->checksumByteSize();
6210          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6211         buf = stream->alloc(totalSize);
6212         ptr = buf;
6213         int tmp = OP_glUniformMatrix4x2fv;memcpy(ptr, &tmp, 4); ptr += 4;
6214         memcpy(ptr, &totalSize, 4);  ptr += 4;
6215
6216                 memcpy(ptr, &location, 4); ptr += 4;
6217                 memcpy(ptr, &count, 4); ptr += 4;
6218                 memcpy(ptr, &transpose, 1); ptr += 1;
6219         *(unsigned int *)(ptr) = __size_value; ptr += 4;
6220         memcpy(ptr, value, __size_value);ptr += __size_value;
6221
6222         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6223         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6224
6225 }
6226
6227 void glUniformMatrix3x4fv_enc(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
6228 {
6229
6230         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6231         IOStream *stream = ctx->m_stream;
6232         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6233         bool useChecksum = checksumCalculator->getVersion() > 0;
6234
6235         const unsigned int __size_value =  (count * 12 * sizeof(GLfloat));
6236          unsigned char *ptr;
6237          unsigned char *buf;
6238          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 1 + __size_value + 1*4;
6239          const size_t checksumSize = checksumCalculator->checksumByteSize();
6240          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6241         buf = stream->alloc(totalSize);
6242         ptr = buf;
6243         int tmp = OP_glUniformMatrix3x4fv;memcpy(ptr, &tmp, 4); ptr += 4;
6244         memcpy(ptr, &totalSize, 4);  ptr += 4;
6245
6246                 memcpy(ptr, &location, 4); ptr += 4;
6247                 memcpy(ptr, &count, 4); ptr += 4;
6248                 memcpy(ptr, &transpose, 1); ptr += 1;
6249         *(unsigned int *)(ptr) = __size_value; ptr += 4;
6250         memcpy(ptr, value, __size_value);ptr += __size_value;
6251
6252         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6253         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6254
6255 }
6256
6257 void glUniformMatrix4x3fv_enc(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
6258 {
6259
6260         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6261         IOStream *stream = ctx->m_stream;
6262         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6263         bool useChecksum = checksumCalculator->getVersion() > 0;
6264
6265         const unsigned int __size_value =  (count * 12 * sizeof(GLfloat));
6266          unsigned char *ptr;
6267          unsigned char *buf;
6268          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 1 + __size_value + 1*4;
6269          const size_t checksumSize = checksumCalculator->checksumByteSize();
6270          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6271         buf = stream->alloc(totalSize);
6272         ptr = buf;
6273         int tmp = OP_glUniformMatrix4x3fv;memcpy(ptr, &tmp, 4); ptr += 4;
6274         memcpy(ptr, &totalSize, 4);  ptr += 4;
6275
6276                 memcpy(ptr, &location, 4); ptr += 4;
6277                 memcpy(ptr, &count, 4); ptr += 4;
6278                 memcpy(ptr, &transpose, 1); ptr += 1;
6279         *(unsigned int *)(ptr) = __size_value; ptr += 4;
6280         memcpy(ptr, value, __size_value);ptr += __size_value;
6281
6282         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6283         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6284
6285 }
6286
6287 void glGetUniformuiv_enc(void *self , GLuint program, GLint location, GLuint* params)
6288 {
6289
6290         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6291         IOStream *stream = ctx->m_stream;
6292         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6293         bool useChecksum = checksumCalculator->getVersion() > 0;
6294
6295         const unsigned int __size_params =  glSizeof(glesv2_enc::uniformType(self, program, location));
6296          unsigned char *ptr;
6297          unsigned char *buf;
6298          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
6299          const size_t checksumSize = checksumCalculator->checksumByteSize();
6300          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6301         buf = stream->alloc(totalSize);
6302         ptr = buf;
6303         int tmp = OP_glGetUniformuiv;memcpy(ptr, &tmp, 4); ptr += 4;
6304         memcpy(ptr, &totalSize, 4);  ptr += 4;
6305
6306                 memcpy(ptr, &program, 4); ptr += 4;
6307                 memcpy(ptr, &location, 4); ptr += 4;
6308         *(unsigned int *)(ptr) = __size_params; ptr += 4;
6309
6310         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6311         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6312
6313         stream->readback(params, __size_params);
6314         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
6315         if (useChecksum) {
6316                 unsigned char *checksumBufPtr = NULL;
6317                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
6318                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
6319                 stream->readback(checksumBufPtr, checksumSize);
6320                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
6321                         ALOGE("glGetUniformuiv: GL communication error, please report this issue to b.android.com.\n");
6322                         abort();
6323                 }
6324         }
6325 }
6326
6327 void glGetActiveUniformsiv_enc(void *self , GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params)
6328 {
6329
6330         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6331         IOStream *stream = ctx->m_stream;
6332         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6333         bool useChecksum = checksumCalculator->getVersion() > 0;
6334
6335         const unsigned int __size_uniformIndices =  (uniformCount * sizeof(GLuint));
6336         const unsigned int __size_params =  (uniformCount * sizeof(GLint));
6337          unsigned char *ptr;
6338          unsigned char *buf;
6339          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_uniformIndices + 4 + 0 + 2*4;
6340          const size_t checksumSize = checksumCalculator->checksumByteSize();
6341          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6342         buf = stream->alloc(totalSize);
6343         ptr = buf;
6344         int tmp = OP_glGetActiveUniformsiv;memcpy(ptr, &tmp, 4); ptr += 4;
6345         memcpy(ptr, &totalSize, 4);  ptr += 4;
6346
6347                 memcpy(ptr, &program, 4); ptr += 4;
6348                 memcpy(ptr, &uniformCount, 4); ptr += 4;
6349         *(unsigned int *)(ptr) = __size_uniformIndices; ptr += 4;
6350         memcpy(ptr, uniformIndices, __size_uniformIndices);ptr += __size_uniformIndices;
6351                 memcpy(ptr, &pname, 4); ptr += 4;
6352         *(unsigned int *)(ptr) = __size_params; ptr += 4;
6353
6354         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6355         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6356
6357         stream->readback(params, __size_params);
6358         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
6359         if (useChecksum) {
6360                 unsigned char *checksumBufPtr = NULL;
6361                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
6362                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
6363                 stream->readback(checksumBufPtr, checksumSize);
6364                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
6365                         ALOGE("glGetActiveUniformsiv: GL communication error, please report this issue to b.android.com.\n");
6366                         abort();
6367                 }
6368         }
6369 }
6370
6371 void glVertexAttribI4i_enc(void *self , GLuint index, GLint v0, GLint v1, GLint v2, GLint v3)
6372 {
6373
6374         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6375         IOStream *stream = ctx->m_stream;
6376         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6377         bool useChecksum = checksumCalculator->getVersion() > 0;
6378
6379          unsigned char *ptr;
6380          unsigned char *buf;
6381          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
6382          const size_t checksumSize = checksumCalculator->checksumByteSize();
6383          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6384         buf = stream->alloc(totalSize);
6385         ptr = buf;
6386         int tmp = OP_glVertexAttribI4i;memcpy(ptr, &tmp, 4); ptr += 4;
6387         memcpy(ptr, &totalSize, 4);  ptr += 4;
6388
6389                 memcpy(ptr, &index, 4); ptr += 4;
6390                 memcpy(ptr, &v0, 4); ptr += 4;
6391                 memcpy(ptr, &v1, 4); ptr += 4;
6392                 memcpy(ptr, &v2, 4); ptr += 4;
6393                 memcpy(ptr, &v3, 4); ptr += 4;
6394
6395         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6396         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6397
6398 }
6399
6400 void glVertexAttribI4ui_enc(void *self , GLuint index, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
6401 {
6402
6403         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6404         IOStream *stream = ctx->m_stream;
6405         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6406         bool useChecksum = checksumCalculator->getVersion() > 0;
6407
6408          unsigned char *ptr;
6409          unsigned char *buf;
6410          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
6411          const size_t checksumSize = checksumCalculator->checksumByteSize();
6412          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6413         buf = stream->alloc(totalSize);
6414         ptr = buf;
6415         int tmp = OP_glVertexAttribI4ui;memcpy(ptr, &tmp, 4); ptr += 4;
6416         memcpy(ptr, &totalSize, 4);  ptr += 4;
6417
6418                 memcpy(ptr, &index, 4); ptr += 4;
6419                 memcpy(ptr, &v0, 4); ptr += 4;
6420                 memcpy(ptr, &v1, 4); ptr += 4;
6421                 memcpy(ptr, &v2, 4); ptr += 4;
6422                 memcpy(ptr, &v3, 4); ptr += 4;
6423
6424         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6425         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6426
6427 }
6428
6429 void glVertexAttribI4iv_enc(void *self , GLuint index, const GLint* v)
6430 {
6431
6432         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6433         IOStream *stream = ctx->m_stream;
6434         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6435         bool useChecksum = checksumCalculator->getVersion() > 0;
6436
6437         const unsigned int __size_v =  (4 * sizeof(GLint));
6438          unsigned char *ptr;
6439          unsigned char *buf;
6440          const size_t sizeWithoutChecksum = 8 + 4 + __size_v + 1*4;
6441          const size_t checksumSize = checksumCalculator->checksumByteSize();
6442          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6443         buf = stream->alloc(totalSize);
6444         ptr = buf;
6445         int tmp = OP_glVertexAttribI4iv;memcpy(ptr, &tmp, 4); ptr += 4;
6446         memcpy(ptr, &totalSize, 4);  ptr += 4;
6447
6448                 memcpy(ptr, &index, 4); ptr += 4;
6449         *(unsigned int *)(ptr) = __size_v; ptr += 4;
6450         memcpy(ptr, v, __size_v);ptr += __size_v;
6451
6452         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6453         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6454
6455 }
6456
6457 void glVertexAttribI4uiv_enc(void *self , GLuint index, const GLuint* v)
6458 {
6459
6460         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6461         IOStream *stream = ctx->m_stream;
6462         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6463         bool useChecksum = checksumCalculator->getVersion() > 0;
6464
6465         const unsigned int __size_v =  (4 * sizeof(GLuint));
6466          unsigned char *ptr;
6467          unsigned char *buf;
6468          const size_t sizeWithoutChecksum = 8 + 4 + __size_v + 1*4;
6469          const size_t checksumSize = checksumCalculator->checksumByteSize();
6470          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6471         buf = stream->alloc(totalSize);
6472         ptr = buf;
6473         int tmp = OP_glVertexAttribI4uiv;memcpy(ptr, &tmp, 4); ptr += 4;
6474         memcpy(ptr, &totalSize, 4);  ptr += 4;
6475
6476                 memcpy(ptr, &index, 4); ptr += 4;
6477         *(unsigned int *)(ptr) = __size_v; ptr += 4;
6478         memcpy(ptr, v, __size_v);ptr += __size_v;
6479
6480         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6481         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6482
6483 }
6484
6485 void glVertexAttribIPointerOffsetAEMU_enc(void *self , GLuint index, GLint size, GLenum type, GLsizei stride, GLuint offset)
6486 {
6487
6488         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6489         IOStream *stream = ctx->m_stream;
6490         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6491         bool useChecksum = checksumCalculator->getVersion() > 0;
6492
6493          unsigned char *ptr;
6494          unsigned char *buf;
6495          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
6496          const size_t checksumSize = checksumCalculator->checksumByteSize();
6497          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6498         buf = stream->alloc(totalSize);
6499         ptr = buf;
6500         int tmp = OP_glVertexAttribIPointerOffsetAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
6501         memcpy(ptr, &totalSize, 4);  ptr += 4;
6502
6503                 memcpy(ptr, &index, 4); ptr += 4;
6504                 memcpy(ptr, &size, 4); ptr += 4;
6505                 memcpy(ptr, &type, 4); ptr += 4;
6506                 memcpy(ptr, &stride, 4); ptr += 4;
6507                 memcpy(ptr, &offset, 4); ptr += 4;
6508
6509         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6510         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6511
6512 }
6513
6514 void glVertexAttribIPointerDataAEMU_enc(void *self , GLuint index, GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
6515 {
6516
6517         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6518         IOStream *stream = ctx->m_stream;
6519         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6520         bool useChecksum = checksumCalculator->getVersion() > 0;
6521
6522         const unsigned int __size_data =  datalen;
6523          unsigned char *ptr;
6524          unsigned char *buf;
6525          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + __size_data + 4 + 1*4;
6526          const size_t checksumSize = checksumCalculator->checksumByteSize();
6527          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6528         buf = stream->alloc(totalSize);
6529         ptr = buf;
6530         int tmp = OP_glVertexAttribIPointerDataAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
6531         memcpy(ptr, &totalSize, 4);  ptr += 4;
6532
6533                 memcpy(ptr, &index, 4); ptr += 4;
6534                 memcpy(ptr, &size, 4); ptr += 4;
6535                 memcpy(ptr, &type, 4); ptr += 4;
6536                 memcpy(ptr, &stride, 4); ptr += 4;
6537         *(unsigned int *)(ptr) = __size_data; ptr += 4;
6538          glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen);ptr += __size_data;
6539                 memcpy(ptr, &datalen, 4); ptr += 4;
6540
6541         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6542         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6543
6544 }
6545
6546 void glGetVertexAttribIiv_enc(void *self , GLuint index, GLenum pname, GLint* params)
6547 {
6548
6549         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6550         IOStream *stream = ctx->m_stream;
6551         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6552         bool useChecksum = checksumCalculator->getVersion() > 0;
6553
6554         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
6555          unsigned char *ptr;
6556          unsigned char *buf;
6557          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
6558          const size_t checksumSize = checksumCalculator->checksumByteSize();
6559          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6560         buf = stream->alloc(totalSize);
6561         ptr = buf;
6562         int tmp = OP_glGetVertexAttribIiv;memcpy(ptr, &tmp, 4); ptr += 4;
6563         memcpy(ptr, &totalSize, 4);  ptr += 4;
6564
6565                 memcpy(ptr, &index, 4); ptr += 4;
6566                 memcpy(ptr, &pname, 4); ptr += 4;
6567         *(unsigned int *)(ptr) = __size_params; ptr += 4;
6568
6569         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6570         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6571
6572         stream->readback(params, __size_params);
6573         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
6574         if (useChecksum) {
6575                 unsigned char *checksumBufPtr = NULL;
6576                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
6577                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
6578                 stream->readback(checksumBufPtr, checksumSize);
6579                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
6580                         ALOGE("glGetVertexAttribIiv: GL communication error, please report this issue to b.android.com.\n");
6581                         abort();
6582                 }
6583         }
6584 }
6585
6586 void glGetVertexAttribIuiv_enc(void *self , GLuint index, GLenum pname, GLuint* params)
6587 {
6588
6589         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6590         IOStream *stream = ctx->m_stream;
6591         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6592         bool useChecksum = checksumCalculator->getVersion() > 0;
6593
6594         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLuint));
6595          unsigned char *ptr;
6596          unsigned char *buf;
6597          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
6598          const size_t checksumSize = checksumCalculator->checksumByteSize();
6599          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6600         buf = stream->alloc(totalSize);
6601         ptr = buf;
6602         int tmp = OP_glGetVertexAttribIuiv;memcpy(ptr, &tmp, 4); ptr += 4;
6603         memcpy(ptr, &totalSize, 4);  ptr += 4;
6604
6605                 memcpy(ptr, &index, 4); ptr += 4;
6606                 memcpy(ptr, &pname, 4); ptr += 4;
6607         *(unsigned int *)(ptr) = __size_params; ptr += 4;
6608
6609         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6610         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6611
6612         stream->readback(params, __size_params);
6613         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
6614         if (useChecksum) {
6615                 unsigned char *checksumBufPtr = NULL;
6616                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
6617                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
6618                 stream->readback(checksumBufPtr, checksumSize);
6619                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
6620                         ALOGE("glGetVertexAttribIuiv: GL communication error, please report this issue to b.android.com.\n");
6621                         abort();
6622                 }
6623         }
6624 }
6625
6626 void glVertexAttribDivisor_enc(void *self , GLuint index, GLuint divisor)
6627 {
6628
6629         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6630         IOStream *stream = ctx->m_stream;
6631         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6632         bool useChecksum = checksumCalculator->getVersion() > 0;
6633
6634          unsigned char *ptr;
6635          unsigned char *buf;
6636          const size_t sizeWithoutChecksum = 8 + 4 + 4;
6637          const size_t checksumSize = checksumCalculator->checksumByteSize();
6638          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6639         buf = stream->alloc(totalSize);
6640         ptr = buf;
6641         int tmp = OP_glVertexAttribDivisor;memcpy(ptr, &tmp, 4); ptr += 4;
6642         memcpy(ptr, &totalSize, 4);  ptr += 4;
6643
6644                 memcpy(ptr, &index, 4); ptr += 4;
6645                 memcpy(ptr, &divisor, 4); ptr += 4;
6646
6647         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6648         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6649
6650 }
6651
6652 void glDrawArraysInstanced_enc(void *self , GLenum mode, GLint first, GLsizei count, GLsizei primcount)
6653 {
6654
6655         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6656         IOStream *stream = ctx->m_stream;
6657         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6658         bool useChecksum = checksumCalculator->getVersion() > 0;
6659
6660          unsigned char *ptr;
6661          unsigned char *buf;
6662          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
6663          const size_t checksumSize = checksumCalculator->checksumByteSize();
6664          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6665         buf = stream->alloc(totalSize);
6666         ptr = buf;
6667         int tmp = OP_glDrawArraysInstanced;memcpy(ptr, &tmp, 4); ptr += 4;
6668         memcpy(ptr, &totalSize, 4);  ptr += 4;
6669
6670                 memcpy(ptr, &mode, 4); ptr += 4;
6671                 memcpy(ptr, &first, 4); ptr += 4;
6672                 memcpy(ptr, &count, 4); ptr += 4;
6673                 memcpy(ptr, &primcount, 4); ptr += 4;
6674
6675         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6676         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6677
6678 }
6679
6680 void glDrawElementsInstancedDataAEMU_enc(void *self , GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount, GLsizei datalen)
6681 {
6682
6683         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6684         IOStream *stream = ctx->m_stream;
6685         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6686         bool useChecksum = checksumCalculator->getVersion() > 0;
6687
6688         const unsigned int __size_indices =  datalen;
6689          unsigned char *ptr;
6690          unsigned char *buf;
6691          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_indices + 4 + 4 + 1*4;
6692          const size_t checksumSize = checksumCalculator->checksumByteSize();
6693          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6694         buf = stream->alloc(totalSize);
6695         ptr = buf;
6696         int tmp = OP_glDrawElementsInstancedDataAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
6697         memcpy(ptr, &totalSize, 4);  ptr += 4;
6698
6699                 memcpy(ptr, &mode, 4); ptr += 4;
6700                 memcpy(ptr, &count, 4); ptr += 4;
6701                 memcpy(ptr, &type, 4); ptr += 4;
6702         *(unsigned int *)(ptr) = __size_indices; ptr += 4;
6703         memcpy(ptr, indices, __size_indices);ptr += __size_indices;
6704                 memcpy(ptr, &primcount, 4); ptr += 4;
6705                 memcpy(ptr, &datalen, 4); ptr += 4;
6706
6707         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6708         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6709
6710 }
6711
6712 void glDrawElementsInstancedOffsetAEMU_enc(void *self , GLenum mode, GLsizei count, GLenum type, GLuint offset, GLsizei primcount)
6713 {
6714
6715         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6716         IOStream *stream = ctx->m_stream;
6717         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6718         bool useChecksum = checksumCalculator->getVersion() > 0;
6719
6720          unsigned char *ptr;
6721          unsigned char *buf;
6722          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
6723          const size_t checksumSize = checksumCalculator->checksumByteSize();
6724          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6725         buf = stream->alloc(totalSize);
6726         ptr = buf;
6727         int tmp = OP_glDrawElementsInstancedOffsetAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
6728         memcpy(ptr, &totalSize, 4);  ptr += 4;
6729
6730                 memcpy(ptr, &mode, 4); ptr += 4;
6731                 memcpy(ptr, &count, 4); ptr += 4;
6732                 memcpy(ptr, &type, 4); ptr += 4;
6733                 memcpy(ptr, &offset, 4); ptr += 4;
6734                 memcpy(ptr, &primcount, 4); ptr += 4;
6735
6736         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6737         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6738
6739 }
6740
6741 void glDrawRangeElementsDataAEMU_enc(void *self , GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices, GLsizei datalen)
6742 {
6743
6744         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6745         IOStream *stream = ctx->m_stream;
6746         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6747         bool useChecksum = checksumCalculator->getVersion() > 0;
6748
6749         const unsigned int __size_indices =  datalen;
6750          unsigned char *ptr;
6751          unsigned char *buf;
6752          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + __size_indices + 4 + 1*4;
6753          const size_t checksumSize = checksumCalculator->checksumByteSize();
6754          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6755         buf = stream->alloc(totalSize);
6756         ptr = buf;
6757         int tmp = OP_glDrawRangeElementsDataAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
6758         memcpy(ptr, &totalSize, 4);  ptr += 4;
6759
6760                 memcpy(ptr, &mode, 4); ptr += 4;
6761                 memcpy(ptr, &start, 4); ptr += 4;
6762                 memcpy(ptr, &end, 4); ptr += 4;
6763                 memcpy(ptr, &count, 4); ptr += 4;
6764                 memcpy(ptr, &type, 4); ptr += 4;
6765         *(unsigned int *)(ptr) = __size_indices; ptr += 4;
6766         memcpy(ptr, indices, __size_indices);ptr += __size_indices;
6767                 memcpy(ptr, &datalen, 4); ptr += 4;
6768
6769         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6770         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6771
6772 }
6773
6774 void glDrawRangeElementsOffsetAEMU_enc(void *self , GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, GLuint offset)
6775 {
6776
6777         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6778         IOStream *stream = ctx->m_stream;
6779         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6780         bool useChecksum = checksumCalculator->getVersion() > 0;
6781
6782          unsigned char *ptr;
6783          unsigned char *buf;
6784          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4;
6785          const size_t checksumSize = checksumCalculator->checksumByteSize();
6786          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6787         buf = stream->alloc(totalSize);
6788         ptr = buf;
6789         int tmp = OP_glDrawRangeElementsOffsetAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
6790         memcpy(ptr, &totalSize, 4);  ptr += 4;
6791
6792                 memcpy(ptr, &mode, 4); ptr += 4;
6793                 memcpy(ptr, &start, 4); ptr += 4;
6794                 memcpy(ptr, &end, 4); ptr += 4;
6795                 memcpy(ptr, &count, 4); ptr += 4;
6796                 memcpy(ptr, &type, 4); ptr += 4;
6797                 memcpy(ptr, &offset, 4); ptr += 4;
6798
6799         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6800         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6801
6802 }
6803
6804 uint64_t glFenceSyncAEMU_enc(void *self , GLenum condition, GLbitfield flags)
6805 {
6806
6807         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6808         IOStream *stream = ctx->m_stream;
6809         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6810         bool useChecksum = checksumCalculator->getVersion() > 0;
6811
6812          unsigned char *ptr;
6813          unsigned char *buf;
6814          const size_t sizeWithoutChecksum = 8 + 4 + 4;
6815          const size_t checksumSize = checksumCalculator->checksumByteSize();
6816          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6817         buf = stream->alloc(totalSize);
6818         ptr = buf;
6819         int tmp = OP_glFenceSyncAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
6820         memcpy(ptr, &totalSize, 4);  ptr += 4;
6821
6822                 memcpy(ptr, &condition, 4); ptr += 4;
6823                 memcpy(ptr, &flags, 4); ptr += 4;
6824
6825         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6826         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6827
6828
6829         uint64_t retval;
6830         stream->readback(&retval, 8);
6831         if (useChecksum) checksumCalculator->addBuffer(&retval, 8);
6832         if (useChecksum) {
6833                 unsigned char *checksumBufPtr = NULL;
6834                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
6835                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
6836                 stream->readback(checksumBufPtr, checksumSize);
6837                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
6838                         ALOGE("glFenceSyncAEMU: GL communication error, please report this issue to b.android.com.\n");
6839                         abort();
6840                 }
6841         }
6842         return retval;
6843 }
6844
6845 GLenum glClientWaitSyncAEMU_enc(void *self , uint64_t wait_on, GLbitfield flags, GLuint64 timeout)
6846 {
6847
6848         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6849         IOStream *stream = ctx->m_stream;
6850         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6851         bool useChecksum = checksumCalculator->getVersion() > 0;
6852
6853          unsigned char *ptr;
6854          unsigned char *buf;
6855          const size_t sizeWithoutChecksum = 8 + 8 + 4 + 8;
6856          const size_t checksumSize = checksumCalculator->checksumByteSize();
6857          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6858         buf = stream->alloc(totalSize);
6859         ptr = buf;
6860         int tmp = OP_glClientWaitSyncAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
6861         memcpy(ptr, &totalSize, 4);  ptr += 4;
6862
6863                 memcpy(ptr, &wait_on, 8); ptr += 8;
6864                 memcpy(ptr, &flags, 4); ptr += 4;
6865                 memcpy(ptr, &timeout, 8); ptr += 8;
6866
6867         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6868         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6869
6870
6871         GLenum retval;
6872         stream->readback(&retval, 4);
6873         if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
6874         if (useChecksum) {
6875                 unsigned char *checksumBufPtr = NULL;
6876                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
6877                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
6878                 stream->readback(checksumBufPtr, checksumSize);
6879                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
6880                         ALOGE("glClientWaitSyncAEMU: GL communication error, please report this issue to b.android.com.\n");
6881                         abort();
6882                 }
6883         }
6884         return retval;
6885 }
6886
6887 void glWaitSyncAEMU_enc(void *self , uint64_t wait_on, GLbitfield flags, GLuint64 timeout)
6888 {
6889
6890         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6891         IOStream *stream = ctx->m_stream;
6892         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6893         bool useChecksum = checksumCalculator->getVersion() > 0;
6894
6895          unsigned char *ptr;
6896          unsigned char *buf;
6897          const size_t sizeWithoutChecksum = 8 + 8 + 4 + 8;
6898          const size_t checksumSize = checksumCalculator->checksumByteSize();
6899          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6900         buf = stream->alloc(totalSize);
6901         ptr = buf;
6902         int tmp = OP_glWaitSyncAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
6903         memcpy(ptr, &totalSize, 4);  ptr += 4;
6904
6905                 memcpy(ptr, &wait_on, 8); ptr += 8;
6906                 memcpy(ptr, &flags, 4); ptr += 4;
6907                 memcpy(ptr, &timeout, 8); ptr += 8;
6908
6909         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6910         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6911
6912 }
6913
6914 void glDeleteSyncAEMU_enc(void *self , uint64_t to_delete)
6915 {
6916
6917         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6918         IOStream *stream = ctx->m_stream;
6919         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6920         bool useChecksum = checksumCalculator->getVersion() > 0;
6921
6922          unsigned char *ptr;
6923          unsigned char *buf;
6924          const size_t sizeWithoutChecksum = 8 + 8;
6925          const size_t checksumSize = checksumCalculator->checksumByteSize();
6926          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6927         buf = stream->alloc(totalSize);
6928         ptr = buf;
6929         int tmp = OP_glDeleteSyncAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
6930         memcpy(ptr, &totalSize, 4);  ptr += 4;
6931
6932                 memcpy(ptr, &to_delete, 8); ptr += 8;
6933
6934         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6935         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6936
6937 }
6938
6939 GLboolean glIsSyncAEMU_enc(void *self , uint64_t sync)
6940 {
6941
6942         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6943         IOStream *stream = ctx->m_stream;
6944         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6945         bool useChecksum = checksumCalculator->getVersion() > 0;
6946
6947          unsigned char *ptr;
6948          unsigned char *buf;
6949          const size_t sizeWithoutChecksum = 8 + 8;
6950          const size_t checksumSize = checksumCalculator->checksumByteSize();
6951          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6952         buf = stream->alloc(totalSize);
6953         ptr = buf;
6954         int tmp = OP_glIsSyncAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
6955         memcpy(ptr, &totalSize, 4);  ptr += 4;
6956
6957                 memcpy(ptr, &sync, 8); ptr += 8;
6958
6959         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6960         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6961
6962
6963         GLboolean retval;
6964         stream->readback(&retval, 1);
6965         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
6966         if (useChecksum) {
6967                 unsigned char *checksumBufPtr = NULL;
6968                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
6969                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
6970                 stream->readback(checksumBufPtr, checksumSize);
6971                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
6972                         ALOGE("glIsSyncAEMU: GL communication error, please report this issue to b.android.com.\n");
6973                         abort();
6974                 }
6975         }
6976         return retval;
6977 }
6978
6979 void glGetSyncivAEMU_enc(void *self , uint64_t sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values)
6980 {
6981
6982         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
6983         IOStream *stream = ctx->m_stream;
6984         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6985         bool useChecksum = checksumCalculator->getVersion() > 0;
6986
6987         const unsigned int __size_length = ((length != NULL) ?  (sizeof(GLsizei)) : 0);
6988         const unsigned int __size_values =  (bufSize * sizeof(GLint));
6989          unsigned char *ptr;
6990          unsigned char *buf;
6991          const size_t sizeWithoutChecksum = 8 + 8 + 4 + 4 + 0 + 0 + 2*4;
6992          const size_t checksumSize = checksumCalculator->checksumByteSize();
6993          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6994         buf = stream->alloc(totalSize);
6995         ptr = buf;
6996         int tmp = OP_glGetSyncivAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
6997         memcpy(ptr, &totalSize, 4);  ptr += 4;
6998
6999                 memcpy(ptr, &sync, 8); ptr += 8;
7000                 memcpy(ptr, &pname, 4); ptr += 4;
7001                 memcpy(ptr, &bufSize, 4); ptr += 4;
7002         *(unsigned int *)(ptr) = __size_length; ptr += 4;
7003         *(unsigned int *)(ptr) = __size_values; ptr += 4;
7004
7005         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7006         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7007
7008         if (length != NULL) {
7009                 stream->readback(length, __size_length);
7010                 if (useChecksum) checksumCalculator->addBuffer(length, __size_length);
7011         }
7012         stream->readback(values, __size_values);
7013         if (useChecksum) checksumCalculator->addBuffer(values, __size_values);
7014         if (useChecksum) {
7015                 unsigned char *checksumBufPtr = NULL;
7016                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
7017                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
7018                 stream->readback(checksumBufPtr, checksumSize);
7019                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
7020                         ALOGE("glGetSyncivAEMU: GL communication error, please report this issue to b.android.com.\n");
7021                         abort();
7022                 }
7023         }
7024 }
7025
7026 void glDrawBuffers_enc(void *self , GLsizei n, const GLenum* bufs)
7027 {
7028
7029         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7030         IOStream *stream = ctx->m_stream;
7031         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7032         bool useChecksum = checksumCalculator->getVersion() > 0;
7033
7034         const unsigned int __size_bufs =  (n * sizeof(GLenum));
7035          unsigned char *ptr;
7036          unsigned char *buf;
7037          const size_t sizeWithoutChecksum = 8 + 4 + __size_bufs + 1*4;
7038          const size_t checksumSize = checksumCalculator->checksumByteSize();
7039          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7040         buf = stream->alloc(totalSize);
7041         ptr = buf;
7042         int tmp = OP_glDrawBuffers;memcpy(ptr, &tmp, 4); ptr += 4;
7043         memcpy(ptr, &totalSize, 4);  ptr += 4;
7044
7045                 memcpy(ptr, &n, 4); ptr += 4;
7046         *(unsigned int *)(ptr) = __size_bufs; ptr += 4;
7047         memcpy(ptr, bufs, __size_bufs);ptr += __size_bufs;
7048
7049         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7050         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7051
7052 }
7053
7054 void glReadBuffer_enc(void *self , GLenum src)
7055 {
7056
7057         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7058         IOStream *stream = ctx->m_stream;
7059         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7060         bool useChecksum = checksumCalculator->getVersion() > 0;
7061
7062          unsigned char *ptr;
7063          unsigned char *buf;
7064          const size_t sizeWithoutChecksum = 8 + 4;
7065          const size_t checksumSize = checksumCalculator->checksumByteSize();
7066          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7067         buf = stream->alloc(totalSize);
7068         ptr = buf;
7069         int tmp = OP_glReadBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
7070         memcpy(ptr, &totalSize, 4);  ptr += 4;
7071
7072                 memcpy(ptr, &src, 4); ptr += 4;
7073
7074         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7075         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7076
7077 }
7078
7079 void glBlitFramebuffer_enc(void *self , GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
7080 {
7081
7082         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7083         IOStream *stream = ctx->m_stream;
7084         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7085         bool useChecksum = checksumCalculator->getVersion() > 0;
7086
7087          unsigned char *ptr;
7088          unsigned char *buf;
7089          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4;
7090          const size_t checksumSize = checksumCalculator->checksumByteSize();
7091          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7092         buf = stream->alloc(totalSize);
7093         ptr = buf;
7094         int tmp = OP_glBlitFramebuffer;memcpy(ptr, &tmp, 4); ptr += 4;
7095         memcpy(ptr, &totalSize, 4);  ptr += 4;
7096
7097                 memcpy(ptr, &srcX0, 4); ptr += 4;
7098                 memcpy(ptr, &srcY0, 4); ptr += 4;
7099                 memcpy(ptr, &srcX1, 4); ptr += 4;
7100                 memcpy(ptr, &srcY1, 4); ptr += 4;
7101                 memcpy(ptr, &dstX0, 4); ptr += 4;
7102                 memcpy(ptr, &dstY0, 4); ptr += 4;
7103                 memcpy(ptr, &dstX1, 4); ptr += 4;
7104                 memcpy(ptr, &dstY1, 4); ptr += 4;
7105                 memcpy(ptr, &mask, 4); ptr += 4;
7106                 memcpy(ptr, &filter, 4); ptr += 4;
7107
7108         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7109         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7110
7111 }
7112
7113 void glInvalidateFramebuffer_enc(void *self , GLenum target, GLsizei numAttachments, const GLenum* attachments)
7114 {
7115
7116         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7117         IOStream *stream = ctx->m_stream;
7118         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7119         bool useChecksum = checksumCalculator->getVersion() > 0;
7120
7121         const unsigned int __size_attachments =  (numAttachments * sizeof(GLenum));
7122          unsigned char *ptr;
7123          unsigned char *buf;
7124          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_attachments + 1*4;
7125          const size_t checksumSize = checksumCalculator->checksumByteSize();
7126          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7127         buf = stream->alloc(totalSize);
7128         ptr = buf;
7129         int tmp = OP_glInvalidateFramebuffer;memcpy(ptr, &tmp, 4); ptr += 4;
7130         memcpy(ptr, &totalSize, 4);  ptr += 4;
7131
7132                 memcpy(ptr, &target, 4); ptr += 4;
7133                 memcpy(ptr, &numAttachments, 4); ptr += 4;
7134         *(unsigned int *)(ptr) = __size_attachments; ptr += 4;
7135         memcpy(ptr, attachments, __size_attachments);ptr += __size_attachments;
7136
7137         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7138         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7139
7140 }
7141
7142 void glInvalidateSubFramebuffer_enc(void *self , GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height)
7143 {
7144
7145         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7146         IOStream *stream = ctx->m_stream;
7147         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7148         bool useChecksum = checksumCalculator->getVersion() > 0;
7149
7150         const unsigned int __size_attachments =  (numAttachments * sizeof(GLenum));
7151          unsigned char *ptr;
7152          unsigned char *buf;
7153          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_attachments + 4 + 4 + 4 + 4 + 1*4;
7154          const size_t checksumSize = checksumCalculator->checksumByteSize();
7155          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7156         buf = stream->alloc(totalSize);
7157         ptr = buf;
7158         int tmp = OP_glInvalidateSubFramebuffer;memcpy(ptr, &tmp, 4); ptr += 4;
7159         memcpy(ptr, &totalSize, 4);  ptr += 4;
7160
7161                 memcpy(ptr, &target, 4); ptr += 4;
7162                 memcpy(ptr, &numAttachments, 4); ptr += 4;
7163         *(unsigned int *)(ptr) = __size_attachments; ptr += 4;
7164         memcpy(ptr, attachments, __size_attachments);ptr += __size_attachments;
7165                 memcpy(ptr, &x, 4); ptr += 4;
7166                 memcpy(ptr, &y, 4); ptr += 4;
7167                 memcpy(ptr, &width, 4); ptr += 4;
7168                 memcpy(ptr, &height, 4); ptr += 4;
7169
7170         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7171         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7172
7173 }
7174
7175 void glFramebufferTextureLayer_enc(void *self , GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
7176 {
7177
7178         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7179         IOStream *stream = ctx->m_stream;
7180         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7181         bool useChecksum = checksumCalculator->getVersion() > 0;
7182
7183          unsigned char *ptr;
7184          unsigned char *buf;
7185          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
7186          const size_t checksumSize = checksumCalculator->checksumByteSize();
7187          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7188         buf = stream->alloc(totalSize);
7189         ptr = buf;
7190         int tmp = OP_glFramebufferTextureLayer;memcpy(ptr, &tmp, 4); ptr += 4;
7191         memcpy(ptr, &totalSize, 4);  ptr += 4;
7192
7193                 memcpy(ptr, &target, 4); ptr += 4;
7194                 memcpy(ptr, &attachment, 4); ptr += 4;
7195                 memcpy(ptr, &texture, 4); ptr += 4;
7196                 memcpy(ptr, &level, 4); ptr += 4;
7197                 memcpy(ptr, &layer, 4); ptr += 4;
7198
7199         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7200         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7201
7202 }
7203
7204 void glRenderbufferStorageMultisample_enc(void *self , GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
7205 {
7206
7207         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7208         IOStream *stream = ctx->m_stream;
7209         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7210         bool useChecksum = checksumCalculator->getVersion() > 0;
7211
7212          unsigned char *ptr;
7213          unsigned char *buf;
7214          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
7215          const size_t checksumSize = checksumCalculator->checksumByteSize();
7216          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7217         buf = stream->alloc(totalSize);
7218         ptr = buf;
7219         int tmp = OP_glRenderbufferStorageMultisample;memcpy(ptr, &tmp, 4); ptr += 4;
7220         memcpy(ptr, &totalSize, 4);  ptr += 4;
7221
7222                 memcpy(ptr, &target, 4); ptr += 4;
7223                 memcpy(ptr, &samples, 4); ptr += 4;
7224                 memcpy(ptr, &internalformat, 4); ptr += 4;
7225                 memcpy(ptr, &width, 4); ptr += 4;
7226                 memcpy(ptr, &height, 4); ptr += 4;
7227
7228         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7229         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7230
7231 }
7232
7233 void glTexStorage2D_enc(void *self , GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
7234 {
7235
7236         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7237         IOStream *stream = ctx->m_stream;
7238         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7239         bool useChecksum = checksumCalculator->getVersion() > 0;
7240
7241          unsigned char *ptr;
7242          unsigned char *buf;
7243          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
7244          const size_t checksumSize = checksumCalculator->checksumByteSize();
7245          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7246         buf = stream->alloc(totalSize);
7247         ptr = buf;
7248         int tmp = OP_glTexStorage2D;memcpy(ptr, &tmp, 4); ptr += 4;
7249         memcpy(ptr, &totalSize, 4);  ptr += 4;
7250
7251                 memcpy(ptr, &target, 4); ptr += 4;
7252                 memcpy(ptr, &levels, 4); ptr += 4;
7253                 memcpy(ptr, &internalformat, 4); ptr += 4;
7254                 memcpy(ptr, &width, 4); ptr += 4;
7255                 memcpy(ptr, &height, 4); ptr += 4;
7256
7257         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7258         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7259
7260 }
7261
7262 void glGetInternalformativ_enc(void *self , GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params)
7263 {
7264
7265         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7266         IOStream *stream = ctx->m_stream;
7267         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7268         bool useChecksum = checksumCalculator->getVersion() > 0;
7269
7270         const unsigned int __size_params =  (sizeof(GLint) * bufSize);
7271          unsigned char *ptr;
7272          unsigned char *buf;
7273          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 0 + 1*4;
7274          const size_t checksumSize = checksumCalculator->checksumByteSize();
7275          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7276         buf = stream->alloc(totalSize);
7277         ptr = buf;
7278         int tmp = OP_glGetInternalformativ;memcpy(ptr, &tmp, 4); ptr += 4;
7279         memcpy(ptr, &totalSize, 4);  ptr += 4;
7280
7281                 memcpy(ptr, &target, 4); ptr += 4;
7282                 memcpy(ptr, &internalformat, 4); ptr += 4;
7283                 memcpy(ptr, &pname, 4); ptr += 4;
7284                 memcpy(ptr, &bufSize, 4); ptr += 4;
7285         *(unsigned int *)(ptr) = __size_params; ptr += 4;
7286
7287         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7288         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7289
7290         stream->readback(params, __size_params);
7291         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
7292         if (useChecksum) {
7293                 unsigned char *checksumBufPtr = NULL;
7294                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
7295                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
7296                 stream->readback(checksumBufPtr, checksumSize);
7297                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
7298                         ALOGE("glGetInternalformativ: GL communication error, please report this issue to b.android.com.\n");
7299                         abort();
7300                 }
7301         }
7302 }
7303
7304 void glBeginTransformFeedback_enc(void *self , GLenum primitiveMode)
7305 {
7306
7307         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7308         IOStream *stream = ctx->m_stream;
7309         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7310         bool useChecksum = checksumCalculator->getVersion() > 0;
7311
7312          unsigned char *ptr;
7313          unsigned char *buf;
7314          const size_t sizeWithoutChecksum = 8 + 4;
7315          const size_t checksumSize = checksumCalculator->checksumByteSize();
7316          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7317         buf = stream->alloc(totalSize);
7318         ptr = buf;
7319         int tmp = OP_glBeginTransformFeedback;memcpy(ptr, &tmp, 4); ptr += 4;
7320         memcpy(ptr, &totalSize, 4);  ptr += 4;
7321
7322                 memcpy(ptr, &primitiveMode, 4); ptr += 4;
7323
7324         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7325         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7326
7327 }
7328
7329 void glEndTransformFeedback_enc(void *self )
7330 {
7331
7332         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7333         IOStream *stream = ctx->m_stream;
7334         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7335         bool useChecksum = checksumCalculator->getVersion() > 0;
7336
7337          unsigned char *ptr;
7338          unsigned char *buf;
7339          const size_t sizeWithoutChecksum = 8;
7340          const size_t checksumSize = checksumCalculator->checksumByteSize();
7341          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7342         buf = stream->alloc(totalSize);
7343         ptr = buf;
7344         int tmp = OP_glEndTransformFeedback;memcpy(ptr, &tmp, 4); ptr += 4;
7345         memcpy(ptr, &totalSize, 4);  ptr += 4;
7346
7347
7348         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7349         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7350
7351 }
7352
7353 void glGenTransformFeedbacks_enc(void *self , GLsizei n, GLuint* ids)
7354 {
7355
7356         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7357         IOStream *stream = ctx->m_stream;
7358         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7359         bool useChecksum = checksumCalculator->getVersion() > 0;
7360
7361         const unsigned int __size_ids =  (n * sizeof(GLuint));
7362          unsigned char *ptr;
7363          unsigned char *buf;
7364          const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
7365          const size_t checksumSize = checksumCalculator->checksumByteSize();
7366          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7367         buf = stream->alloc(totalSize);
7368         ptr = buf;
7369         int tmp = OP_glGenTransformFeedbacks;memcpy(ptr, &tmp, 4); ptr += 4;
7370         memcpy(ptr, &totalSize, 4);  ptr += 4;
7371
7372                 memcpy(ptr, &n, 4); ptr += 4;
7373         *(unsigned int *)(ptr) = __size_ids; ptr += 4;
7374
7375         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7376         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7377
7378         stream->readback(ids, __size_ids);
7379         if (useChecksum) checksumCalculator->addBuffer(ids, __size_ids);
7380         if (useChecksum) {
7381                 unsigned char *checksumBufPtr = NULL;
7382                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
7383                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
7384                 stream->readback(checksumBufPtr, checksumSize);
7385                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
7386                         ALOGE("glGenTransformFeedbacks: GL communication error, please report this issue to b.android.com.\n");
7387                         abort();
7388                 }
7389         }
7390 }
7391
7392 void glDeleteTransformFeedbacks_enc(void *self , GLsizei n, const GLuint* ids)
7393 {
7394
7395         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7396         IOStream *stream = ctx->m_stream;
7397         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7398         bool useChecksum = checksumCalculator->getVersion() > 0;
7399
7400         const unsigned int __size_ids =  (n * sizeof(GLuint));
7401          unsigned char *ptr;
7402          unsigned char *buf;
7403          const size_t sizeWithoutChecksum = 8 + 4 + __size_ids + 1*4;
7404          const size_t checksumSize = checksumCalculator->checksumByteSize();
7405          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7406         buf = stream->alloc(totalSize);
7407         ptr = buf;
7408         int tmp = OP_glDeleteTransformFeedbacks;memcpy(ptr, &tmp, 4); ptr += 4;
7409         memcpy(ptr, &totalSize, 4);  ptr += 4;
7410
7411                 memcpy(ptr, &n, 4); ptr += 4;
7412         *(unsigned int *)(ptr) = __size_ids; ptr += 4;
7413         memcpy(ptr, ids, __size_ids);ptr += __size_ids;
7414
7415         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7416         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7417
7418 }
7419
7420 void glBindTransformFeedback_enc(void *self , GLenum target, GLuint id)
7421 {
7422
7423         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7424         IOStream *stream = ctx->m_stream;
7425         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7426         bool useChecksum = checksumCalculator->getVersion() > 0;
7427
7428          unsigned char *ptr;
7429          unsigned char *buf;
7430          const size_t sizeWithoutChecksum = 8 + 4 + 4;
7431          const size_t checksumSize = checksumCalculator->checksumByteSize();
7432          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7433         buf = stream->alloc(totalSize);
7434         ptr = buf;
7435         int tmp = OP_glBindTransformFeedback;memcpy(ptr, &tmp, 4); ptr += 4;
7436         memcpy(ptr, &totalSize, 4);  ptr += 4;
7437
7438                 memcpy(ptr, &target, 4); ptr += 4;
7439                 memcpy(ptr, &id, 4); ptr += 4;
7440
7441         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7442         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7443
7444 }
7445
7446 void glPauseTransformFeedback_enc(void *self )
7447 {
7448
7449         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7450         IOStream *stream = ctx->m_stream;
7451         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7452         bool useChecksum = checksumCalculator->getVersion() > 0;
7453
7454          unsigned char *ptr;
7455          unsigned char *buf;
7456          const size_t sizeWithoutChecksum = 8;
7457          const size_t checksumSize = checksumCalculator->checksumByteSize();
7458          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7459         buf = stream->alloc(totalSize);
7460         ptr = buf;
7461         int tmp = OP_glPauseTransformFeedback;memcpy(ptr, &tmp, 4); ptr += 4;
7462         memcpy(ptr, &totalSize, 4);  ptr += 4;
7463
7464
7465         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7466         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7467
7468 }
7469
7470 void glResumeTransformFeedback_enc(void *self )
7471 {
7472
7473         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7474         IOStream *stream = ctx->m_stream;
7475         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7476         bool useChecksum = checksumCalculator->getVersion() > 0;
7477
7478          unsigned char *ptr;
7479          unsigned char *buf;
7480          const size_t sizeWithoutChecksum = 8;
7481          const size_t checksumSize = checksumCalculator->checksumByteSize();
7482          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7483         buf = stream->alloc(totalSize);
7484         ptr = buf;
7485         int tmp = OP_glResumeTransformFeedback;memcpy(ptr, &tmp, 4); ptr += 4;
7486         memcpy(ptr, &totalSize, 4);  ptr += 4;
7487
7488
7489         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7490         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7491
7492 }
7493
7494 GLboolean glIsTransformFeedback_enc(void *self , GLuint id)
7495 {
7496
7497         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7498         IOStream *stream = ctx->m_stream;
7499         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7500         bool useChecksum = checksumCalculator->getVersion() > 0;
7501
7502          unsigned char *ptr;
7503          unsigned char *buf;
7504          const size_t sizeWithoutChecksum = 8 + 4;
7505          const size_t checksumSize = checksumCalculator->checksumByteSize();
7506          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7507         buf = stream->alloc(totalSize);
7508         ptr = buf;
7509         int tmp = OP_glIsTransformFeedback;memcpy(ptr, &tmp, 4); ptr += 4;
7510         memcpy(ptr, &totalSize, 4);  ptr += 4;
7511
7512                 memcpy(ptr, &id, 4); ptr += 4;
7513
7514         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7515         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7516
7517
7518         GLboolean retval;
7519         stream->readback(&retval, 1);
7520         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
7521         if (useChecksum) {
7522                 unsigned char *checksumBufPtr = NULL;
7523                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
7524                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
7525                 stream->readback(checksumBufPtr, checksumSize);
7526                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
7527                         ALOGE("glIsTransformFeedback: GL communication error, please report this issue to b.android.com.\n");
7528                         abort();
7529                 }
7530         }
7531         return retval;
7532 }
7533
7534 void glTransformFeedbackVaryingsAEMU_enc(void *self , GLuint program, GLsizei count, const char* packedVaryings, GLuint packedVaryingsLen, GLenum bufferMode)
7535 {
7536
7537         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7538         IOStream *stream = ctx->m_stream;
7539         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7540         bool useChecksum = checksumCalculator->getVersion() > 0;
7541
7542         const unsigned int __size_packedVaryings =  packedVaryingsLen;
7543          unsigned char *ptr;
7544          unsigned char *buf;
7545          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_packedVaryings + 4 + 4 + 1*4;
7546          const size_t checksumSize = checksumCalculator->checksumByteSize();
7547          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7548         buf = stream->alloc(totalSize);
7549         ptr = buf;
7550         int tmp = OP_glTransformFeedbackVaryingsAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
7551         memcpy(ptr, &totalSize, 4);  ptr += 4;
7552
7553                 memcpy(ptr, &program, 4); ptr += 4;
7554                 memcpy(ptr, &count, 4); ptr += 4;
7555         *(unsigned int *)(ptr) = __size_packedVaryings; ptr += 4;
7556         memcpy(ptr, packedVaryings, __size_packedVaryings);ptr += __size_packedVaryings;
7557                 memcpy(ptr, &packedVaryingsLen, 4); ptr += 4;
7558                 memcpy(ptr, &bufferMode, 4); ptr += 4;
7559
7560         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7561         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7562
7563 }
7564
7565 void glGetTransformFeedbackVarying_enc(void *self , GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, char* name)
7566 {
7567
7568         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7569         IOStream *stream = ctx->m_stream;
7570         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7571         bool useChecksum = checksumCalculator->getVersion() > 0;
7572
7573         const unsigned int __size_length = ((length != NULL) ?  (sizeof(GLsizei)) : 0);
7574         const unsigned int __size_size =  (sizeof(GLsizei));
7575         const unsigned int __size_type = ((type != NULL) ?  (sizeof(GLenum)) : 0);
7576         const unsigned int __size_name = ((name != NULL) ?  bufSize : 0);
7577          unsigned char *ptr;
7578          unsigned char *buf;
7579          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 0 + 0 + 0 + 0 + 4*4;
7580          const size_t checksumSize = checksumCalculator->checksumByteSize();
7581          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7582         buf = stream->alloc(totalSize);
7583         ptr = buf;
7584         int tmp = OP_glGetTransformFeedbackVarying;memcpy(ptr, &tmp, 4); ptr += 4;
7585         memcpy(ptr, &totalSize, 4);  ptr += 4;
7586
7587                 memcpy(ptr, &program, 4); ptr += 4;
7588                 memcpy(ptr, &index, 4); ptr += 4;
7589                 memcpy(ptr, &bufSize, 4); ptr += 4;
7590         *(unsigned int *)(ptr) = __size_length; ptr += 4;
7591         *(unsigned int *)(ptr) = __size_size; ptr += 4;
7592         *(unsigned int *)(ptr) = __size_type; ptr += 4;
7593         *(unsigned int *)(ptr) = __size_name; ptr += 4;
7594
7595         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7596         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7597
7598         if (length != NULL) {
7599                 stream->readback(length, __size_length);
7600                 if (useChecksum) checksumCalculator->addBuffer(length, __size_length);
7601         }
7602         stream->readback(size, __size_size);
7603         if (useChecksum) checksumCalculator->addBuffer(size, __size_size);
7604         if (type != NULL) {
7605                 stream->readback(type, __size_type);
7606                 if (useChecksum) checksumCalculator->addBuffer(type, __size_type);
7607         }
7608         if (name != NULL) {
7609                 stream->readback(name, __size_name);
7610                 if (useChecksum) checksumCalculator->addBuffer(name, __size_name);
7611         }
7612         if (useChecksum) {
7613                 unsigned char *checksumBufPtr = NULL;
7614                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
7615                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
7616                 stream->readback(checksumBufPtr, checksumSize);
7617                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
7618                         ALOGE("glGetTransformFeedbackVarying: GL communication error, please report this issue to b.android.com.\n");
7619                         abort();
7620                 }
7621         }
7622 }
7623
7624 void glGenSamplers_enc(void *self , GLsizei n, GLuint* samplers)
7625 {
7626
7627         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7628         IOStream *stream = ctx->m_stream;
7629         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7630         bool useChecksum = checksumCalculator->getVersion() > 0;
7631
7632         const unsigned int __size_samplers =  (n * sizeof(GLuint));
7633          unsigned char *ptr;
7634          unsigned char *buf;
7635          const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
7636          const size_t checksumSize = checksumCalculator->checksumByteSize();
7637          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7638         buf = stream->alloc(totalSize);
7639         ptr = buf;
7640         int tmp = OP_glGenSamplers;memcpy(ptr, &tmp, 4); ptr += 4;
7641         memcpy(ptr, &totalSize, 4);  ptr += 4;
7642
7643                 memcpy(ptr, &n, 4); ptr += 4;
7644         *(unsigned int *)(ptr) = __size_samplers; ptr += 4;
7645
7646         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7647         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7648
7649         stream->readback(samplers, __size_samplers);
7650         if (useChecksum) checksumCalculator->addBuffer(samplers, __size_samplers);
7651         if (useChecksum) {
7652                 unsigned char *checksumBufPtr = NULL;
7653                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
7654                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
7655                 stream->readback(checksumBufPtr, checksumSize);
7656                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
7657                         ALOGE("glGenSamplers: GL communication error, please report this issue to b.android.com.\n");
7658                         abort();
7659                 }
7660         }
7661 }
7662
7663 void glDeleteSamplers_enc(void *self , GLsizei n, const GLuint* samplers)
7664 {
7665
7666         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7667         IOStream *stream = ctx->m_stream;
7668         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7669         bool useChecksum = checksumCalculator->getVersion() > 0;
7670
7671         const unsigned int __size_samplers =  (n * sizeof(GLuint));
7672          unsigned char *ptr;
7673          unsigned char *buf;
7674          const size_t sizeWithoutChecksum = 8 + 4 + __size_samplers + 1*4;
7675          const size_t checksumSize = checksumCalculator->checksumByteSize();
7676          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7677         buf = stream->alloc(totalSize);
7678         ptr = buf;
7679         int tmp = OP_glDeleteSamplers;memcpy(ptr, &tmp, 4); ptr += 4;
7680         memcpy(ptr, &totalSize, 4);  ptr += 4;
7681
7682                 memcpy(ptr, &n, 4); ptr += 4;
7683         *(unsigned int *)(ptr) = __size_samplers; ptr += 4;
7684         memcpy(ptr, samplers, __size_samplers);ptr += __size_samplers;
7685
7686         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7687         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7688
7689 }
7690
7691 void glBindSampler_enc(void *self , GLuint unit, GLuint sampler)
7692 {
7693
7694         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7695         IOStream *stream = ctx->m_stream;
7696         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7697         bool useChecksum = checksumCalculator->getVersion() > 0;
7698
7699          unsigned char *ptr;
7700          unsigned char *buf;
7701          const size_t sizeWithoutChecksum = 8 + 4 + 4;
7702          const size_t checksumSize = checksumCalculator->checksumByteSize();
7703          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7704         buf = stream->alloc(totalSize);
7705         ptr = buf;
7706         int tmp = OP_glBindSampler;memcpy(ptr, &tmp, 4); ptr += 4;
7707         memcpy(ptr, &totalSize, 4);  ptr += 4;
7708
7709                 memcpy(ptr, &unit, 4); ptr += 4;
7710                 memcpy(ptr, &sampler, 4); ptr += 4;
7711
7712         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7713         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7714
7715 }
7716
7717 void glSamplerParameterf_enc(void *self , GLuint sampler, GLenum pname, GLfloat param)
7718 {
7719
7720         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7721         IOStream *stream = ctx->m_stream;
7722         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7723         bool useChecksum = checksumCalculator->getVersion() > 0;
7724
7725          unsigned char *ptr;
7726          unsigned char *buf;
7727          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
7728          const size_t checksumSize = checksumCalculator->checksumByteSize();
7729          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7730         buf = stream->alloc(totalSize);
7731         ptr = buf;
7732         int tmp = OP_glSamplerParameterf;memcpy(ptr, &tmp, 4); ptr += 4;
7733         memcpy(ptr, &totalSize, 4);  ptr += 4;
7734
7735                 memcpy(ptr, &sampler, 4); ptr += 4;
7736                 memcpy(ptr, &pname, 4); ptr += 4;
7737                 memcpy(ptr, &param, 4); ptr += 4;
7738
7739         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7740         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7741
7742 }
7743
7744 void glSamplerParameteri_enc(void *self , GLuint sampler, GLenum pname, GLint param)
7745 {
7746
7747         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7748         IOStream *stream = ctx->m_stream;
7749         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7750         bool useChecksum = checksumCalculator->getVersion() > 0;
7751
7752          unsigned char *ptr;
7753          unsigned char *buf;
7754          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
7755          const size_t checksumSize = checksumCalculator->checksumByteSize();
7756          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7757         buf = stream->alloc(totalSize);
7758         ptr = buf;
7759         int tmp = OP_glSamplerParameteri;memcpy(ptr, &tmp, 4); ptr += 4;
7760         memcpy(ptr, &totalSize, 4);  ptr += 4;
7761
7762                 memcpy(ptr, &sampler, 4); ptr += 4;
7763                 memcpy(ptr, &pname, 4); ptr += 4;
7764                 memcpy(ptr, &param, 4); ptr += 4;
7765
7766         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7767         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7768
7769 }
7770
7771 void glSamplerParameterfv_enc(void *self , GLuint sampler, GLenum pname, const GLfloat* params)
7772 {
7773
7774         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7775         IOStream *stream = ctx->m_stream;
7776         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7777         bool useChecksum = checksumCalculator->getVersion() > 0;
7778
7779         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
7780          unsigned char *ptr;
7781          unsigned char *buf;
7782          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
7783          const size_t checksumSize = checksumCalculator->checksumByteSize();
7784          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7785         buf = stream->alloc(totalSize);
7786         ptr = buf;
7787         int tmp = OP_glSamplerParameterfv;memcpy(ptr, &tmp, 4); ptr += 4;
7788         memcpy(ptr, &totalSize, 4);  ptr += 4;
7789
7790                 memcpy(ptr, &sampler, 4); ptr += 4;
7791                 memcpy(ptr, &pname, 4); ptr += 4;
7792         *(unsigned int *)(ptr) = __size_params; ptr += 4;
7793         memcpy(ptr, params, __size_params);ptr += __size_params;
7794
7795         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7796         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7797
7798 }
7799
7800 void glSamplerParameteriv_enc(void *self , GLuint sampler, GLenum pname, const GLint* params)
7801 {
7802
7803         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7804         IOStream *stream = ctx->m_stream;
7805         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7806         bool useChecksum = checksumCalculator->getVersion() > 0;
7807
7808         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
7809          unsigned char *ptr;
7810          unsigned char *buf;
7811          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
7812          const size_t checksumSize = checksumCalculator->checksumByteSize();
7813          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7814         buf = stream->alloc(totalSize);
7815         ptr = buf;
7816         int tmp = OP_glSamplerParameteriv;memcpy(ptr, &tmp, 4); ptr += 4;
7817         memcpy(ptr, &totalSize, 4);  ptr += 4;
7818
7819                 memcpy(ptr, &sampler, 4); ptr += 4;
7820                 memcpy(ptr, &pname, 4); ptr += 4;
7821         *(unsigned int *)(ptr) = __size_params; ptr += 4;
7822         memcpy(ptr, params, __size_params);ptr += __size_params;
7823
7824         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7825         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7826
7827 }
7828
7829 void glGetSamplerParameterfv_enc(void *self , GLuint sampler, GLenum pname, GLfloat* params)
7830 {
7831
7832         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7833         IOStream *stream = ctx->m_stream;
7834         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7835         bool useChecksum = checksumCalculator->getVersion() > 0;
7836
7837         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
7838          unsigned char *ptr;
7839          unsigned char *buf;
7840          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
7841          const size_t checksumSize = checksumCalculator->checksumByteSize();
7842          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7843         buf = stream->alloc(totalSize);
7844         ptr = buf;
7845         int tmp = OP_glGetSamplerParameterfv;memcpy(ptr, &tmp, 4); ptr += 4;
7846         memcpy(ptr, &totalSize, 4);  ptr += 4;
7847
7848                 memcpy(ptr, &sampler, 4); ptr += 4;
7849                 memcpy(ptr, &pname, 4); ptr += 4;
7850         *(unsigned int *)(ptr) = __size_params; ptr += 4;
7851
7852         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7853         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7854
7855         stream->readback(params, __size_params);
7856         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
7857         if (useChecksum) {
7858                 unsigned char *checksumBufPtr = NULL;
7859                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
7860                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
7861                 stream->readback(checksumBufPtr, checksumSize);
7862                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
7863                         ALOGE("glGetSamplerParameterfv: GL communication error, please report this issue to b.android.com.\n");
7864                         abort();
7865                 }
7866         }
7867 }
7868
7869 void glGetSamplerParameteriv_enc(void *self , GLuint sampler, GLenum pname, GLint* params)
7870 {
7871
7872         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7873         IOStream *stream = ctx->m_stream;
7874         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7875         bool useChecksum = checksumCalculator->getVersion() > 0;
7876
7877         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
7878          unsigned char *ptr;
7879          unsigned char *buf;
7880          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
7881          const size_t checksumSize = checksumCalculator->checksumByteSize();
7882          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7883         buf = stream->alloc(totalSize);
7884         ptr = buf;
7885         int tmp = OP_glGetSamplerParameteriv;memcpy(ptr, &tmp, 4); ptr += 4;
7886         memcpy(ptr, &totalSize, 4);  ptr += 4;
7887
7888                 memcpy(ptr, &sampler, 4); ptr += 4;
7889                 memcpy(ptr, &pname, 4); ptr += 4;
7890         *(unsigned int *)(ptr) = __size_params; ptr += 4;
7891
7892         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7893         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7894
7895         stream->readback(params, __size_params);
7896         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
7897         if (useChecksum) {
7898                 unsigned char *checksumBufPtr = NULL;
7899                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
7900                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
7901                 stream->readback(checksumBufPtr, checksumSize);
7902                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
7903                         ALOGE("glGetSamplerParameteriv: GL communication error, please report this issue to b.android.com.\n");
7904                         abort();
7905                 }
7906         }
7907 }
7908
7909 GLboolean glIsSampler_enc(void *self , GLuint sampler)
7910 {
7911
7912         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7913         IOStream *stream = ctx->m_stream;
7914         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7915         bool useChecksum = checksumCalculator->getVersion() > 0;
7916
7917          unsigned char *ptr;
7918          unsigned char *buf;
7919          const size_t sizeWithoutChecksum = 8 + 4;
7920          const size_t checksumSize = checksumCalculator->checksumByteSize();
7921          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7922         buf = stream->alloc(totalSize);
7923         ptr = buf;
7924         int tmp = OP_glIsSampler;memcpy(ptr, &tmp, 4); ptr += 4;
7925         memcpy(ptr, &totalSize, 4);  ptr += 4;
7926
7927                 memcpy(ptr, &sampler, 4); ptr += 4;
7928
7929         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7930         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7931
7932
7933         GLboolean retval;
7934         stream->readback(&retval, 1);
7935         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
7936         if (useChecksum) {
7937                 unsigned char *checksumBufPtr = NULL;
7938                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
7939                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
7940                 stream->readback(checksumBufPtr, checksumSize);
7941                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
7942                         ALOGE("glIsSampler: GL communication error, please report this issue to b.android.com.\n");
7943                         abort();
7944                 }
7945         }
7946         return retval;
7947 }
7948
7949 void glGenQueries_enc(void *self , GLsizei n, GLuint* queries)
7950 {
7951
7952         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7953         IOStream *stream = ctx->m_stream;
7954         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7955         bool useChecksum = checksumCalculator->getVersion() > 0;
7956
7957         const unsigned int __size_queries =  (n * sizeof(GLuint));
7958          unsigned char *ptr;
7959          unsigned char *buf;
7960          const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
7961          const size_t checksumSize = checksumCalculator->checksumByteSize();
7962          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7963         buf = stream->alloc(totalSize);
7964         ptr = buf;
7965         int tmp = OP_glGenQueries;memcpy(ptr, &tmp, 4); ptr += 4;
7966         memcpy(ptr, &totalSize, 4);  ptr += 4;
7967
7968                 memcpy(ptr, &n, 4); ptr += 4;
7969         *(unsigned int *)(ptr) = __size_queries; ptr += 4;
7970
7971         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7972         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7973
7974         stream->readback(queries, __size_queries);
7975         if (useChecksum) checksumCalculator->addBuffer(queries, __size_queries);
7976         if (useChecksum) {
7977                 unsigned char *checksumBufPtr = NULL;
7978                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
7979                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
7980                 stream->readback(checksumBufPtr, checksumSize);
7981                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
7982                         ALOGE("glGenQueries: GL communication error, please report this issue to b.android.com.\n");
7983                         abort();
7984                 }
7985         }
7986 }
7987
7988 void glDeleteQueries_enc(void *self , GLsizei n, const GLuint* queries)
7989 {
7990
7991         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
7992         IOStream *stream = ctx->m_stream;
7993         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7994         bool useChecksum = checksumCalculator->getVersion() > 0;
7995
7996         const unsigned int __size_queries =  (n * sizeof(GLuint));
7997          unsigned char *ptr;
7998          unsigned char *buf;
7999          const size_t sizeWithoutChecksum = 8 + 4 + __size_queries + 1*4;
8000          const size_t checksumSize = checksumCalculator->checksumByteSize();
8001          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8002         buf = stream->alloc(totalSize);
8003         ptr = buf;
8004         int tmp = OP_glDeleteQueries;memcpy(ptr, &tmp, 4); ptr += 4;
8005         memcpy(ptr, &totalSize, 4);  ptr += 4;
8006
8007                 memcpy(ptr, &n, 4); ptr += 4;
8008         *(unsigned int *)(ptr) = __size_queries; ptr += 4;
8009         memcpy(ptr, queries, __size_queries);ptr += __size_queries;
8010
8011         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8012         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8013
8014 }
8015
8016 void glBeginQuery_enc(void *self , GLenum target, GLuint query)
8017 {
8018
8019         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8020         IOStream *stream = ctx->m_stream;
8021         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8022         bool useChecksum = checksumCalculator->getVersion() > 0;
8023
8024          unsigned char *ptr;
8025          unsigned char *buf;
8026          const size_t sizeWithoutChecksum = 8 + 4 + 4;
8027          const size_t checksumSize = checksumCalculator->checksumByteSize();
8028          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8029         buf = stream->alloc(totalSize);
8030         ptr = buf;
8031         int tmp = OP_glBeginQuery;memcpy(ptr, &tmp, 4); ptr += 4;
8032         memcpy(ptr, &totalSize, 4);  ptr += 4;
8033
8034                 memcpy(ptr, &target, 4); ptr += 4;
8035                 memcpy(ptr, &query, 4); ptr += 4;
8036
8037         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8038         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8039
8040 }
8041
8042 void glEndQuery_enc(void *self , GLenum target)
8043 {
8044
8045         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8046         IOStream *stream = ctx->m_stream;
8047         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8048         bool useChecksum = checksumCalculator->getVersion() > 0;
8049
8050          unsigned char *ptr;
8051          unsigned char *buf;
8052          const size_t sizeWithoutChecksum = 8 + 4;
8053          const size_t checksumSize = checksumCalculator->checksumByteSize();
8054          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8055         buf = stream->alloc(totalSize);
8056         ptr = buf;
8057         int tmp = OP_glEndQuery;memcpy(ptr, &tmp, 4); ptr += 4;
8058         memcpy(ptr, &totalSize, 4);  ptr += 4;
8059
8060                 memcpy(ptr, &target, 4); ptr += 4;
8061
8062         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8063         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8064
8065 }
8066
8067 void glGetQueryiv_enc(void *self , GLenum target, GLenum pname, GLint* params)
8068 {
8069
8070         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8071         IOStream *stream = ctx->m_stream;
8072         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8073         bool useChecksum = checksumCalculator->getVersion() > 0;
8074
8075         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
8076          unsigned char *ptr;
8077          unsigned char *buf;
8078          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
8079          const size_t checksumSize = checksumCalculator->checksumByteSize();
8080          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8081         buf = stream->alloc(totalSize);
8082         ptr = buf;
8083         int tmp = OP_glGetQueryiv;memcpy(ptr, &tmp, 4); ptr += 4;
8084         memcpy(ptr, &totalSize, 4);  ptr += 4;
8085
8086                 memcpy(ptr, &target, 4); ptr += 4;
8087                 memcpy(ptr, &pname, 4); ptr += 4;
8088         *(unsigned int *)(ptr) = __size_params; ptr += 4;
8089
8090         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8091         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8092
8093         stream->readback(params, __size_params);
8094         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
8095         if (useChecksum) {
8096                 unsigned char *checksumBufPtr = NULL;
8097                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
8098                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
8099                 stream->readback(checksumBufPtr, checksumSize);
8100                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
8101                         ALOGE("glGetQueryiv: GL communication error, please report this issue to b.android.com.\n");
8102                         abort();
8103                 }
8104         }
8105 }
8106
8107 void glGetQueryObjectuiv_enc(void *self , GLuint query, GLenum pname, GLuint* params)
8108 {
8109
8110         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8111         IOStream *stream = ctx->m_stream;
8112         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8113         bool useChecksum = checksumCalculator->getVersion() > 0;
8114
8115         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLuint));
8116          unsigned char *ptr;
8117          unsigned char *buf;
8118          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
8119          const size_t checksumSize = checksumCalculator->checksumByteSize();
8120          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8121         buf = stream->alloc(totalSize);
8122         ptr = buf;
8123         int tmp = OP_glGetQueryObjectuiv;memcpy(ptr, &tmp, 4); ptr += 4;
8124         memcpy(ptr, &totalSize, 4);  ptr += 4;
8125
8126                 memcpy(ptr, &query, 4); ptr += 4;
8127                 memcpy(ptr, &pname, 4); ptr += 4;
8128         *(unsigned int *)(ptr) = __size_params; ptr += 4;
8129
8130         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8131         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8132
8133         stream->readback(params, __size_params);
8134         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
8135         if (useChecksum) {
8136                 unsigned char *checksumBufPtr = NULL;
8137                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
8138                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
8139                 stream->readback(checksumBufPtr, checksumSize);
8140                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
8141                         ALOGE("glGetQueryObjectuiv: GL communication error, please report this issue to b.android.com.\n");
8142                         abort();
8143                 }
8144         }
8145 }
8146
8147 GLboolean glIsQuery_enc(void *self , GLuint query)
8148 {
8149
8150         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8151         IOStream *stream = ctx->m_stream;
8152         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8153         bool useChecksum = checksumCalculator->getVersion() > 0;
8154
8155          unsigned char *ptr;
8156          unsigned char *buf;
8157          const size_t sizeWithoutChecksum = 8 + 4;
8158          const size_t checksumSize = checksumCalculator->checksumByteSize();
8159          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8160         buf = stream->alloc(totalSize);
8161         ptr = buf;
8162         int tmp = OP_glIsQuery;memcpy(ptr, &tmp, 4); ptr += 4;
8163         memcpy(ptr, &totalSize, 4);  ptr += 4;
8164
8165                 memcpy(ptr, &query, 4); ptr += 4;
8166
8167         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8168         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8169
8170
8171         GLboolean retval;
8172         stream->readback(&retval, 1);
8173         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
8174         if (useChecksum) {
8175                 unsigned char *checksumBufPtr = NULL;
8176                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
8177                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
8178                 stream->readback(checksumBufPtr, checksumSize);
8179                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
8180                         ALOGE("glIsQuery: GL communication error, please report this issue to b.android.com.\n");
8181                         abort();
8182                 }
8183         }
8184         return retval;
8185 }
8186
8187 void glProgramParameteri_enc(void *self , GLuint program, GLenum pname, GLint value)
8188 {
8189
8190         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8191         IOStream *stream = ctx->m_stream;
8192         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8193         bool useChecksum = checksumCalculator->getVersion() > 0;
8194
8195          unsigned char *ptr;
8196          unsigned char *buf;
8197          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
8198          const size_t checksumSize = checksumCalculator->checksumByteSize();
8199          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8200         buf = stream->alloc(totalSize);
8201         ptr = buf;
8202         int tmp = OP_glProgramParameteri;memcpy(ptr, &tmp, 4); ptr += 4;
8203         memcpy(ptr, &totalSize, 4);  ptr += 4;
8204
8205                 memcpy(ptr, &program, 4); ptr += 4;
8206                 memcpy(ptr, &pname, 4); ptr += 4;
8207                 memcpy(ptr, &value, 4); ptr += 4;
8208
8209         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8210         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8211
8212 }
8213
8214 void glProgramBinary_enc(void *self , GLuint program, GLenum binaryFormat, const void* binary, GLsizei length)
8215 {
8216
8217         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8218         IOStream *stream = ctx->m_stream;
8219         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8220         bool useChecksum = checksumCalculator->getVersion() > 0;
8221
8222         const unsigned int __size_binary =  length;
8223          unsigned char *ptr;
8224          unsigned char *buf;
8225          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_binary + 4 + 1*4;
8226          const size_t checksumSize = checksumCalculator->checksumByteSize();
8227          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8228         buf = stream->alloc(totalSize);
8229         ptr = buf;
8230         int tmp = OP_glProgramBinary;memcpy(ptr, &tmp, 4); ptr += 4;
8231         memcpy(ptr, &totalSize, 4);  ptr += 4;
8232
8233                 memcpy(ptr, &program, 4); ptr += 4;
8234                 memcpy(ptr, &binaryFormat, 4); ptr += 4;
8235         *(unsigned int *)(ptr) = __size_binary; ptr += 4;
8236         memcpy(ptr, binary, __size_binary);ptr += __size_binary;
8237                 memcpy(ptr, &length, 4); ptr += 4;
8238
8239         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8240         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8241
8242 }
8243
8244 void glGetProgramBinary_enc(void *self , GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, void* binary)
8245 {
8246
8247         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8248         IOStream *stream = ctx->m_stream;
8249         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8250         bool useChecksum = checksumCalculator->getVersion() > 0;
8251
8252         const unsigned int __size_length = ((length != NULL) ?  (sizeof(GLsizei)) : 0);
8253         const unsigned int __size_binaryFormat =  (sizeof(GLenum));
8254         const unsigned int __size_binary =  bufSize;
8255          unsigned char *ptr;
8256          unsigned char *buf;
8257          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 0 + 0 + 3*4;
8258          const size_t checksumSize = checksumCalculator->checksumByteSize();
8259          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8260         buf = stream->alloc(totalSize);
8261         ptr = buf;
8262         int tmp = OP_glGetProgramBinary;memcpy(ptr, &tmp, 4); ptr += 4;
8263         memcpy(ptr, &totalSize, 4);  ptr += 4;
8264
8265                 memcpy(ptr, &program, 4); ptr += 4;
8266                 memcpy(ptr, &bufSize, 4); ptr += 4;
8267         *(unsigned int *)(ptr) = __size_length; ptr += 4;
8268         *(unsigned int *)(ptr) = __size_binaryFormat; ptr += 4;
8269         *(unsigned int *)(ptr) = __size_binary; ptr += 4;
8270
8271         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8272         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8273
8274         if (length != NULL) {
8275                 stream->readback(length, __size_length);
8276                 if (useChecksum) checksumCalculator->addBuffer(length, __size_length);
8277         }
8278         stream->readback(binaryFormat, __size_binaryFormat);
8279         if (useChecksum) checksumCalculator->addBuffer(binaryFormat, __size_binaryFormat);
8280         stream->readback(binary, __size_binary);
8281         if (useChecksum) checksumCalculator->addBuffer(binary, __size_binary);
8282         if (useChecksum) {
8283                 unsigned char *checksumBufPtr = NULL;
8284                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
8285                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
8286                 stream->readback(checksumBufPtr, checksumSize);
8287                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
8288                         ALOGE("glGetProgramBinary: GL communication error, please report this issue to b.android.com.\n");
8289                         abort();
8290                 }
8291         }
8292 }
8293
8294 GLint glGetFragDataLocation_enc(void *self , GLuint program, const char* name)
8295 {
8296
8297         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8298         IOStream *stream = ctx->m_stream;
8299         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8300         bool useChecksum = checksumCalculator->getVersion() > 0;
8301
8302         const unsigned int __size_name =  (strlen(name) + 1);
8303          unsigned char *ptr;
8304          unsigned char *buf;
8305          const size_t sizeWithoutChecksum = 8 + 4 + __size_name + 1*4;
8306          const size_t checksumSize = checksumCalculator->checksumByteSize();
8307          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8308         buf = stream->alloc(totalSize);
8309         ptr = buf;
8310         int tmp = OP_glGetFragDataLocation;memcpy(ptr, &tmp, 4); ptr += 4;
8311         memcpy(ptr, &totalSize, 4);  ptr += 4;
8312
8313                 memcpy(ptr, &program, 4); ptr += 4;
8314         *(unsigned int *)(ptr) = __size_name; ptr += 4;
8315         memcpy(ptr, name, __size_name);ptr += __size_name;
8316
8317         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8318         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8319
8320
8321         GLint retval;
8322         stream->readback(&retval, 4);
8323         if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
8324         if (useChecksum) {
8325                 unsigned char *checksumBufPtr = NULL;
8326                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
8327                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
8328                 stream->readback(checksumBufPtr, checksumSize);
8329                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
8330                         ALOGE("glGetFragDataLocation: GL communication error, please report this issue to b.android.com.\n");
8331                         abort();
8332                 }
8333         }
8334         return retval;
8335 }
8336
8337 void glGetInteger64v_enc(void *self , GLenum pname, GLint64* data)
8338 {
8339
8340         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8341         IOStream *stream = ctx->m_stream;
8342         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8343         bool useChecksum = checksumCalculator->getVersion() > 0;
8344
8345         const unsigned int __size_data =  (glUtilsParamSize(pname) * sizeof(GLint64));
8346          unsigned char *ptr;
8347          unsigned char *buf;
8348          const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
8349          const size_t checksumSize = checksumCalculator->checksumByteSize();
8350          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8351         buf = stream->alloc(totalSize);
8352         ptr = buf;
8353         int tmp = OP_glGetInteger64v;memcpy(ptr, &tmp, 4); ptr += 4;
8354         memcpy(ptr, &totalSize, 4);  ptr += 4;
8355
8356                 memcpy(ptr, &pname, 4); ptr += 4;
8357         *(unsigned int *)(ptr) = __size_data; ptr += 4;
8358
8359         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8360         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8361
8362         stream->readback(data, __size_data);
8363         if (useChecksum) checksumCalculator->addBuffer(data, __size_data);
8364         if (useChecksum) {
8365                 unsigned char *checksumBufPtr = NULL;
8366                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
8367                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
8368                 stream->readback(checksumBufPtr, checksumSize);
8369                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
8370                         ALOGE("glGetInteger64v: GL communication error, please report this issue to b.android.com.\n");
8371                         abort();
8372                 }
8373         }
8374 }
8375
8376 void glGetIntegeri_v_enc(void *self , GLenum target, GLuint index, GLint* data)
8377 {
8378
8379         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8380         IOStream *stream = ctx->m_stream;
8381         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8382         bool useChecksum = checksumCalculator->getVersion() > 0;
8383
8384         const unsigned int __size_data =  (sizeof(GLint));
8385          unsigned char *ptr;
8386          unsigned char *buf;
8387          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
8388          const size_t checksumSize = checksumCalculator->checksumByteSize();
8389          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8390         buf = stream->alloc(totalSize);
8391         ptr = buf;
8392         int tmp = OP_glGetIntegeri_v;memcpy(ptr, &tmp, 4); ptr += 4;
8393         memcpy(ptr, &totalSize, 4);  ptr += 4;
8394
8395                 memcpy(ptr, &target, 4); ptr += 4;
8396                 memcpy(ptr, &index, 4); ptr += 4;
8397         *(unsigned int *)(ptr) = __size_data; ptr += 4;
8398
8399         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8400         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8401
8402         stream->readback(data, __size_data);
8403         if (useChecksum) checksumCalculator->addBuffer(data, __size_data);
8404         if (useChecksum) {
8405                 unsigned char *checksumBufPtr = NULL;
8406                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
8407                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
8408                 stream->readback(checksumBufPtr, checksumSize);
8409                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
8410                         ALOGE("glGetIntegeri_v: GL communication error, please report this issue to b.android.com.\n");
8411                         abort();
8412                 }
8413         }
8414 }
8415
8416 void glGetInteger64i_v_enc(void *self , GLenum target, GLuint index, GLint64* data)
8417 {
8418
8419         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8420         IOStream *stream = ctx->m_stream;
8421         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8422         bool useChecksum = checksumCalculator->getVersion() > 0;
8423
8424         const unsigned int __size_data =  (sizeof(GLint64));
8425          unsigned char *ptr;
8426          unsigned char *buf;
8427          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
8428          const size_t checksumSize = checksumCalculator->checksumByteSize();
8429          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8430         buf = stream->alloc(totalSize);
8431         ptr = buf;
8432         int tmp = OP_glGetInteger64i_v;memcpy(ptr, &tmp, 4); ptr += 4;
8433         memcpy(ptr, &totalSize, 4);  ptr += 4;
8434
8435                 memcpy(ptr, &target, 4); ptr += 4;
8436                 memcpy(ptr, &index, 4); ptr += 4;
8437         *(unsigned int *)(ptr) = __size_data; ptr += 4;
8438
8439         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8440         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8441
8442         stream->readback(data, __size_data);
8443         if (useChecksum) checksumCalculator->addBuffer(data, __size_data);
8444         if (useChecksum) {
8445                 unsigned char *checksumBufPtr = NULL;
8446                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
8447                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
8448                 stream->readback(checksumBufPtr, checksumSize);
8449                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
8450                         ALOGE("glGetInteger64i_v: GL communication error, please report this issue to b.android.com.\n");
8451                         abort();
8452                 }
8453         }
8454 }
8455
8456 void glTexImage3D_enc(void *self , GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* data)
8457 {
8458
8459         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8460         IOStream *stream = ctx->m_stream;
8461         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8462         bool useChecksum = checksumCalculator->getVersion() > 0;
8463
8464         const unsigned int __size_data = ((data != NULL) ?  glesv2_enc::pixelDataSize3D(self, width, height, depth, format, type, 0) : 0);
8465          unsigned char *ptr;
8466          unsigned char *buf;
8467          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_data + 1*4;
8468          const size_t checksumSize = checksumCalculator->checksumByteSize();
8469          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8470         buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
8471         ptr = buf;
8472         int tmp = OP_glTexImage3D;memcpy(ptr, &tmp, 4); ptr += 4;
8473         memcpy(ptr, &totalSize, 4);  ptr += 4;
8474
8475                 memcpy(ptr, &target, 4); ptr += 4;
8476                 memcpy(ptr, &level, 4); ptr += 4;
8477                 memcpy(ptr, &internalFormat, 4); ptr += 4;
8478                 memcpy(ptr, &width, 4); ptr += 4;
8479                 memcpy(ptr, &height, 4); ptr += 4;
8480                 memcpy(ptr, &depth, 4); ptr += 4;
8481                 memcpy(ptr, &border, 4); ptr += 4;
8482                 memcpy(ptr, &format, 4); ptr += 4;
8483                 memcpy(ptr, &type, 4); ptr += 4;
8484
8485         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8486         stream->flush();
8487         stream->writeFully(&__size_data,4);
8488         if (useChecksum) checksumCalculator->addBuffer(&__size_data,4);
8489         if (data != NULL) {
8490                 stream->writeFully(data, __size_data);
8491                 if (useChecksum) checksumCalculator->addBuffer(data, __size_data);
8492         }
8493         buf = stream->alloc(checksumSize);
8494         if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
8495
8496 }
8497
8498 void glTexImage3DOffsetAEMU_enc(void *self , GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, GLuint offset)
8499 {
8500
8501         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8502         IOStream *stream = ctx->m_stream;
8503         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8504         bool useChecksum = checksumCalculator->getVersion() > 0;
8505
8506          unsigned char *ptr;
8507          unsigned char *buf;
8508          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4;
8509          const size_t checksumSize = checksumCalculator->checksumByteSize();
8510          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8511         buf = stream->alloc(totalSize);
8512         ptr = buf;
8513         int tmp = OP_glTexImage3DOffsetAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
8514         memcpy(ptr, &totalSize, 4);  ptr += 4;
8515
8516                 memcpy(ptr, &target, 4); ptr += 4;
8517                 memcpy(ptr, &level, 4); ptr += 4;
8518                 memcpy(ptr, &internalFormat, 4); ptr += 4;
8519                 memcpy(ptr, &width, 4); ptr += 4;
8520                 memcpy(ptr, &height, 4); ptr += 4;
8521                 memcpy(ptr, &depth, 4); ptr += 4;
8522                 memcpy(ptr, &border, 4); ptr += 4;
8523                 memcpy(ptr, &format, 4); ptr += 4;
8524                 memcpy(ptr, &type, 4); ptr += 4;
8525                 memcpy(ptr, &offset, 4); ptr += 4;
8526
8527         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8528         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8529
8530 }
8531
8532 void glTexStorage3D_enc(void *self , GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
8533 {
8534
8535         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8536         IOStream *stream = ctx->m_stream;
8537         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8538         bool useChecksum = checksumCalculator->getVersion() > 0;
8539
8540          unsigned char *ptr;
8541          unsigned char *buf;
8542          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4;
8543          const size_t checksumSize = checksumCalculator->checksumByteSize();
8544          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8545         buf = stream->alloc(totalSize);
8546         ptr = buf;
8547         int tmp = OP_glTexStorage3D;memcpy(ptr, &tmp, 4); ptr += 4;
8548         memcpy(ptr, &totalSize, 4);  ptr += 4;
8549
8550                 memcpy(ptr, &target, 4); ptr += 4;
8551                 memcpy(ptr, &levels, 4); ptr += 4;
8552                 memcpy(ptr, &internalformat, 4); ptr += 4;
8553                 memcpy(ptr, &width, 4); ptr += 4;
8554                 memcpy(ptr, &height, 4); ptr += 4;
8555                 memcpy(ptr, &depth, 4); ptr += 4;
8556
8557         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8558         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8559
8560 }
8561
8562 void glTexSubImage3D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* data)
8563 {
8564
8565         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8566         IOStream *stream = ctx->m_stream;
8567         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8568         bool useChecksum = checksumCalculator->getVersion() > 0;
8569
8570         const unsigned int __size_data = ((data != NULL) ?  glesv2_enc::pixelDataSize3D(self, width, height, depth, format, type, 0) : 0);
8571          unsigned char *ptr;
8572          unsigned char *buf;
8573          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_data + 1*4;
8574          const size_t checksumSize = checksumCalculator->checksumByteSize();
8575          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8576         buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
8577         ptr = buf;
8578         int tmp = OP_glTexSubImage3D;memcpy(ptr, &tmp, 4); ptr += 4;
8579         memcpy(ptr, &totalSize, 4);  ptr += 4;
8580
8581                 memcpy(ptr, &target, 4); ptr += 4;
8582                 memcpy(ptr, &level, 4); ptr += 4;
8583                 memcpy(ptr, &xoffset, 4); ptr += 4;
8584                 memcpy(ptr, &yoffset, 4); ptr += 4;
8585                 memcpy(ptr, &zoffset, 4); ptr += 4;
8586                 memcpy(ptr, &width, 4); ptr += 4;
8587                 memcpy(ptr, &height, 4); ptr += 4;
8588                 memcpy(ptr, &depth, 4); ptr += 4;
8589                 memcpy(ptr, &format, 4); ptr += 4;
8590                 memcpy(ptr, &type, 4); ptr += 4;
8591
8592         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8593         stream->flush();
8594         stream->writeFully(&__size_data,4);
8595         if (useChecksum) checksumCalculator->addBuffer(&__size_data,4);
8596         if (data != NULL) {
8597                 stream->writeFully(data, __size_data);
8598                 if (useChecksum) checksumCalculator->addBuffer(data, __size_data);
8599         }
8600         buf = stream->alloc(checksumSize);
8601         if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
8602
8603 }
8604
8605 void glTexSubImage3DOffsetAEMU_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLuint offset)
8606 {
8607
8608         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8609         IOStream *stream = ctx->m_stream;
8610         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8611         bool useChecksum = checksumCalculator->getVersion() > 0;
8612
8613          unsigned char *ptr;
8614          unsigned char *buf;
8615          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4;
8616          const size_t checksumSize = checksumCalculator->checksumByteSize();
8617          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8618         buf = stream->alloc(totalSize);
8619         ptr = buf;
8620         int tmp = OP_glTexSubImage3DOffsetAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
8621         memcpy(ptr, &totalSize, 4);  ptr += 4;
8622
8623                 memcpy(ptr, &target, 4); ptr += 4;
8624                 memcpy(ptr, &level, 4); ptr += 4;
8625                 memcpy(ptr, &xoffset, 4); ptr += 4;
8626                 memcpy(ptr, &yoffset, 4); ptr += 4;
8627                 memcpy(ptr, &zoffset, 4); ptr += 4;
8628                 memcpy(ptr, &width, 4); ptr += 4;
8629                 memcpy(ptr, &height, 4); ptr += 4;
8630                 memcpy(ptr, &depth, 4); ptr += 4;
8631                 memcpy(ptr, &format, 4); ptr += 4;
8632                 memcpy(ptr, &type, 4); ptr += 4;
8633                 memcpy(ptr, &offset, 4); ptr += 4;
8634
8635         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8636         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8637
8638 }
8639
8640 void glCompressedTexImage3D_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data)
8641 {
8642
8643         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8644         IOStream *stream = ctx->m_stream;
8645         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8646         bool useChecksum = checksumCalculator->getVersion() > 0;
8647
8648         const unsigned int __size_data = ((data != NULL) ?  imageSize : 0);
8649          unsigned char *ptr;
8650          unsigned char *buf;
8651          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_data + 1*4;
8652          const size_t checksumSize = checksumCalculator->checksumByteSize();
8653          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8654         buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
8655         ptr = buf;
8656         int tmp = OP_glCompressedTexImage3D;memcpy(ptr, &tmp, 4); ptr += 4;
8657         memcpy(ptr, &totalSize, 4);  ptr += 4;
8658
8659                 memcpy(ptr, &target, 4); ptr += 4;
8660                 memcpy(ptr, &level, 4); ptr += 4;
8661                 memcpy(ptr, &internalformat, 4); ptr += 4;
8662                 memcpy(ptr, &width, 4); ptr += 4;
8663                 memcpy(ptr, &height, 4); ptr += 4;
8664                 memcpy(ptr, &depth, 4); ptr += 4;
8665                 memcpy(ptr, &border, 4); ptr += 4;
8666                 memcpy(ptr, &imageSize, 4); ptr += 4;
8667
8668         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8669         stream->flush();
8670         stream->writeFully(&__size_data,4);
8671         if (useChecksum) checksumCalculator->addBuffer(&__size_data,4);
8672         if (data != NULL) {
8673                 stream->writeFully(data, __size_data);
8674                 if (useChecksum) checksumCalculator->addBuffer(data, __size_data);
8675         }
8676         buf = stream->alloc(checksumSize);
8677         if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
8678
8679 }
8680
8681 void glCompressedTexImage3DOffsetAEMU_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, GLuint offset)
8682 {
8683
8684         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8685         IOStream *stream = ctx->m_stream;
8686         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8687         bool useChecksum = checksumCalculator->getVersion() > 0;
8688
8689          unsigned char *ptr;
8690          unsigned char *buf;
8691          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4;
8692          const size_t checksumSize = checksumCalculator->checksumByteSize();
8693          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8694         buf = stream->alloc(totalSize);
8695         ptr = buf;
8696         int tmp = OP_glCompressedTexImage3DOffsetAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
8697         memcpy(ptr, &totalSize, 4);  ptr += 4;
8698
8699                 memcpy(ptr, &target, 4); ptr += 4;
8700                 memcpy(ptr, &level, 4); ptr += 4;
8701                 memcpy(ptr, &internalformat, 4); ptr += 4;
8702                 memcpy(ptr, &width, 4); ptr += 4;
8703                 memcpy(ptr, &height, 4); ptr += 4;
8704                 memcpy(ptr, &depth, 4); ptr += 4;
8705                 memcpy(ptr, &border, 4); ptr += 4;
8706                 memcpy(ptr, &imageSize, 4); ptr += 4;
8707                 memcpy(ptr, &offset, 4); ptr += 4;
8708
8709         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8710         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8711
8712 }
8713
8714 void glCompressedTexSubImage3D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data)
8715 {
8716
8717         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8718         IOStream *stream = ctx->m_stream;
8719         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8720         bool useChecksum = checksumCalculator->getVersion() > 0;
8721
8722         const unsigned int __size_data = ((data != NULL) ?  imageSize : 0);
8723          unsigned char *ptr;
8724          unsigned char *buf;
8725          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_data + 1*4;
8726          const size_t checksumSize = checksumCalculator->checksumByteSize();
8727          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8728         buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
8729         ptr = buf;
8730         int tmp = OP_glCompressedTexSubImage3D;memcpy(ptr, &tmp, 4); ptr += 4;
8731         memcpy(ptr, &totalSize, 4);  ptr += 4;
8732
8733                 memcpy(ptr, &target, 4); ptr += 4;
8734                 memcpy(ptr, &level, 4); ptr += 4;
8735                 memcpy(ptr, &xoffset, 4); ptr += 4;
8736                 memcpy(ptr, &yoffset, 4); ptr += 4;
8737                 memcpy(ptr, &zoffset, 4); ptr += 4;
8738                 memcpy(ptr, &width, 4); ptr += 4;
8739                 memcpy(ptr, &height, 4); ptr += 4;
8740                 memcpy(ptr, &depth, 4); ptr += 4;
8741                 memcpy(ptr, &format, 4); ptr += 4;
8742                 memcpy(ptr, &imageSize, 4); ptr += 4;
8743
8744         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8745         stream->flush();
8746         stream->writeFully(&__size_data,4);
8747         if (useChecksum) checksumCalculator->addBuffer(&__size_data,4);
8748         if (data != NULL) {
8749                 stream->writeFully(data, __size_data);
8750                 if (useChecksum) checksumCalculator->addBuffer(data, __size_data);
8751         }
8752         buf = stream->alloc(checksumSize);
8753         if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
8754
8755 }
8756
8757 void glCompressedTexSubImage3DOffsetAEMU_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, GLuint data)
8758 {
8759
8760         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8761         IOStream *stream = ctx->m_stream;
8762         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8763         bool useChecksum = checksumCalculator->getVersion() > 0;
8764
8765          unsigned char *ptr;
8766          unsigned char *buf;
8767          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4;
8768          const size_t checksumSize = checksumCalculator->checksumByteSize();
8769          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8770         buf = stream->alloc(totalSize);
8771         ptr = buf;
8772         int tmp = OP_glCompressedTexSubImage3DOffsetAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
8773         memcpy(ptr, &totalSize, 4);  ptr += 4;
8774
8775                 memcpy(ptr, &target, 4); ptr += 4;
8776                 memcpy(ptr, &level, 4); ptr += 4;
8777                 memcpy(ptr, &xoffset, 4); ptr += 4;
8778                 memcpy(ptr, &yoffset, 4); ptr += 4;
8779                 memcpy(ptr, &zoffset, 4); ptr += 4;
8780                 memcpy(ptr, &width, 4); ptr += 4;
8781                 memcpy(ptr, &height, 4); ptr += 4;
8782                 memcpy(ptr, &depth, 4); ptr += 4;
8783                 memcpy(ptr, &format, 4); ptr += 4;
8784                 memcpy(ptr, &imageSize, 4); ptr += 4;
8785                 memcpy(ptr, &data, 4); ptr += 4;
8786
8787         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8788         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8789
8790 }
8791
8792 void glCopyTexSubImage3D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
8793 {
8794
8795         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8796         IOStream *stream = ctx->m_stream;
8797         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8798         bool useChecksum = checksumCalculator->getVersion() > 0;
8799
8800          unsigned char *ptr;
8801          unsigned char *buf;
8802          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4;
8803          const size_t checksumSize = checksumCalculator->checksumByteSize();
8804          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8805         buf = stream->alloc(totalSize);
8806         ptr = buf;
8807         int tmp = OP_glCopyTexSubImage3D;memcpy(ptr, &tmp, 4); ptr += 4;
8808         memcpy(ptr, &totalSize, 4);  ptr += 4;
8809
8810                 memcpy(ptr, &target, 4); ptr += 4;
8811                 memcpy(ptr, &level, 4); ptr += 4;
8812                 memcpy(ptr, &xoffset, 4); ptr += 4;
8813                 memcpy(ptr, &yoffset, 4); ptr += 4;
8814                 memcpy(ptr, &zoffset, 4); ptr += 4;
8815                 memcpy(ptr, &x, 4); ptr += 4;
8816                 memcpy(ptr, &y, 4); ptr += 4;
8817                 memcpy(ptr, &width, 4); ptr += 4;
8818                 memcpy(ptr, &height, 4); ptr += 4;
8819
8820         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8821         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8822
8823 }
8824
8825 void glGetBooleani_v_enc(void *self , GLenum target, GLuint index, GLboolean* data)
8826 {
8827
8828         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8829         IOStream *stream = ctx->m_stream;
8830         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8831         bool useChecksum = checksumCalculator->getVersion() > 0;
8832
8833         const unsigned int __size_data =  (sizeof(GLboolean));
8834          unsigned char *ptr;
8835          unsigned char *buf;
8836          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
8837          const size_t checksumSize = checksumCalculator->checksumByteSize();
8838          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8839         buf = stream->alloc(totalSize);
8840         ptr = buf;
8841         int tmp = OP_glGetBooleani_v;memcpy(ptr, &tmp, 4); ptr += 4;
8842         memcpy(ptr, &totalSize, 4);  ptr += 4;
8843
8844                 memcpy(ptr, &target, 4); ptr += 4;
8845                 memcpy(ptr, &index, 4); ptr += 4;
8846         *(unsigned int *)(ptr) = __size_data; ptr += 4;
8847
8848         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8849         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8850
8851         stream->readback(data, __size_data);
8852         if (useChecksum) checksumCalculator->addBuffer(data, __size_data);
8853         if (useChecksum) {
8854                 unsigned char *checksumBufPtr = NULL;
8855                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
8856                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
8857                 stream->readback(checksumBufPtr, checksumSize);
8858                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
8859                         ALOGE("glGetBooleani_v: GL communication error, please report this issue to b.android.com.\n");
8860                         abort();
8861                 }
8862         }
8863 }
8864
8865 void glMemoryBarrier_enc(void *self , GLbitfield barriers)
8866 {
8867
8868         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8869         IOStream *stream = ctx->m_stream;
8870         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8871         bool useChecksum = checksumCalculator->getVersion() > 0;
8872
8873          unsigned char *ptr;
8874          unsigned char *buf;
8875          const size_t sizeWithoutChecksum = 8 + 4;
8876          const size_t checksumSize = checksumCalculator->checksumByteSize();
8877          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8878         buf = stream->alloc(totalSize);
8879         ptr = buf;
8880         int tmp = OP_glMemoryBarrier;memcpy(ptr, &tmp, 4); ptr += 4;
8881         memcpy(ptr, &totalSize, 4);  ptr += 4;
8882
8883                 memcpy(ptr, &barriers, 4); ptr += 4;
8884
8885         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8886         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8887
8888 }
8889
8890 void glMemoryBarrierByRegion_enc(void *self , GLbitfield barriers)
8891 {
8892
8893         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8894         IOStream *stream = ctx->m_stream;
8895         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8896         bool useChecksum = checksumCalculator->getVersion() > 0;
8897
8898          unsigned char *ptr;
8899          unsigned char *buf;
8900          const size_t sizeWithoutChecksum = 8 + 4;
8901          const size_t checksumSize = checksumCalculator->checksumByteSize();
8902          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8903         buf = stream->alloc(totalSize);
8904         ptr = buf;
8905         int tmp = OP_glMemoryBarrierByRegion;memcpy(ptr, &tmp, 4); ptr += 4;
8906         memcpy(ptr, &totalSize, 4);  ptr += 4;
8907
8908                 memcpy(ptr, &barriers, 4); ptr += 4;
8909
8910         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8911         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8912
8913 }
8914
8915 void glGenProgramPipelines_enc(void *self , GLsizei n, GLuint* pipelines)
8916 {
8917
8918         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8919         IOStream *stream = ctx->m_stream;
8920         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8921         bool useChecksum = checksumCalculator->getVersion() > 0;
8922
8923         const unsigned int __size_pipelines =  (n * sizeof(GLuint));
8924          unsigned char *ptr;
8925          unsigned char *buf;
8926          const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
8927          const size_t checksumSize = checksumCalculator->checksumByteSize();
8928          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8929         buf = stream->alloc(totalSize);
8930         ptr = buf;
8931         int tmp = OP_glGenProgramPipelines;memcpy(ptr, &tmp, 4); ptr += 4;
8932         memcpy(ptr, &totalSize, 4);  ptr += 4;
8933
8934                 memcpy(ptr, &n, 4); ptr += 4;
8935         *(unsigned int *)(ptr) = __size_pipelines; ptr += 4;
8936
8937         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8938         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8939
8940         stream->readback(pipelines, __size_pipelines);
8941         if (useChecksum) checksumCalculator->addBuffer(pipelines, __size_pipelines);
8942         if (useChecksum) {
8943                 unsigned char *checksumBufPtr = NULL;
8944                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
8945                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
8946                 stream->readback(checksumBufPtr, checksumSize);
8947                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
8948                         ALOGE("glGenProgramPipelines: GL communication error, please report this issue to b.android.com.\n");
8949                         abort();
8950                 }
8951         }
8952 }
8953
8954 void glDeleteProgramPipelines_enc(void *self , GLsizei n, const GLuint* pipelines)
8955 {
8956
8957         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8958         IOStream *stream = ctx->m_stream;
8959         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8960         bool useChecksum = checksumCalculator->getVersion() > 0;
8961
8962         const unsigned int __size_pipelines =  (n * sizeof(GLuint));
8963          unsigned char *ptr;
8964          unsigned char *buf;
8965          const size_t sizeWithoutChecksum = 8 + 4 + __size_pipelines + 1*4;
8966          const size_t checksumSize = checksumCalculator->checksumByteSize();
8967          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8968         buf = stream->alloc(totalSize);
8969         ptr = buf;
8970         int tmp = OP_glDeleteProgramPipelines;memcpy(ptr, &tmp, 4); ptr += 4;
8971         memcpy(ptr, &totalSize, 4);  ptr += 4;
8972
8973                 memcpy(ptr, &n, 4); ptr += 4;
8974         *(unsigned int *)(ptr) = __size_pipelines; ptr += 4;
8975         memcpy(ptr, pipelines, __size_pipelines);ptr += __size_pipelines;
8976
8977         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8978         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8979
8980 }
8981
8982 void glBindProgramPipeline_enc(void *self , GLuint pipeline)
8983 {
8984
8985         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
8986         IOStream *stream = ctx->m_stream;
8987         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8988         bool useChecksum = checksumCalculator->getVersion() > 0;
8989
8990          unsigned char *ptr;
8991          unsigned char *buf;
8992          const size_t sizeWithoutChecksum = 8 + 4;
8993          const size_t checksumSize = checksumCalculator->checksumByteSize();
8994          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8995         buf = stream->alloc(totalSize);
8996         ptr = buf;
8997         int tmp = OP_glBindProgramPipeline;memcpy(ptr, &tmp, 4); ptr += 4;
8998         memcpy(ptr, &totalSize, 4);  ptr += 4;
8999
9000                 memcpy(ptr, &pipeline, 4); ptr += 4;
9001
9002         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9003         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9004
9005 }
9006
9007 void glGetProgramPipelineiv_enc(void *self , GLuint pipeline, GLenum pname, GLint* params)
9008 {
9009
9010         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9011         IOStream *stream = ctx->m_stream;
9012         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9013         bool useChecksum = checksumCalculator->getVersion() > 0;
9014
9015         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
9016          unsigned char *ptr;
9017          unsigned char *buf;
9018          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
9019          const size_t checksumSize = checksumCalculator->checksumByteSize();
9020          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9021         buf = stream->alloc(totalSize);
9022         ptr = buf;
9023         int tmp = OP_glGetProgramPipelineiv;memcpy(ptr, &tmp, 4); ptr += 4;
9024         memcpy(ptr, &totalSize, 4);  ptr += 4;
9025
9026                 memcpy(ptr, &pipeline, 4); ptr += 4;
9027                 memcpy(ptr, &pname, 4); ptr += 4;
9028         *(unsigned int *)(ptr) = __size_params; ptr += 4;
9029
9030         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9031         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9032
9033         stream->readback(params, __size_params);
9034         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
9035         if (useChecksum) {
9036                 unsigned char *checksumBufPtr = NULL;
9037                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
9038                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
9039                 stream->readback(checksumBufPtr, checksumSize);
9040                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
9041                         ALOGE("glGetProgramPipelineiv: GL communication error, please report this issue to b.android.com.\n");
9042                         abort();
9043                 }
9044         }
9045 }
9046
9047 void glGetProgramPipelineInfoLog_enc(void *self , GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog)
9048 {
9049
9050         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9051         IOStream *stream = ctx->m_stream;
9052         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9053         bool useChecksum = checksumCalculator->getVersion() > 0;
9054
9055         const unsigned int __size_length = ((length != NULL) ?  sizeof(GLsizei) : 0);
9056         const unsigned int __size_infoLog =  bufSize;
9057          unsigned char *ptr;
9058          unsigned char *buf;
9059          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 0 + 2*4;
9060          const size_t checksumSize = checksumCalculator->checksumByteSize();
9061          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9062         buf = stream->alloc(totalSize);
9063         ptr = buf;
9064         int tmp = OP_glGetProgramPipelineInfoLog;memcpy(ptr, &tmp, 4); ptr += 4;
9065         memcpy(ptr, &totalSize, 4);  ptr += 4;
9066
9067                 memcpy(ptr, &pipeline, 4); ptr += 4;
9068                 memcpy(ptr, &bufSize, 4); ptr += 4;
9069         *(unsigned int *)(ptr) = __size_length; ptr += 4;
9070         *(unsigned int *)(ptr) = __size_infoLog; ptr += 4;
9071
9072         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9073         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9074
9075         if (length != NULL) {
9076                 stream->readback(length, __size_length);
9077                 if (useChecksum) checksumCalculator->addBuffer(length, __size_length);
9078         }
9079         stream->readback(infoLog, __size_infoLog);
9080         if (useChecksum) checksumCalculator->addBuffer(infoLog, __size_infoLog);
9081         if (useChecksum) {
9082                 unsigned char *checksumBufPtr = NULL;
9083                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
9084                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
9085                 stream->readback(checksumBufPtr, checksumSize);
9086                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
9087                         ALOGE("glGetProgramPipelineInfoLog: GL communication error, please report this issue to b.android.com.\n");
9088                         abort();
9089                 }
9090         }
9091 }
9092
9093 void glValidateProgramPipeline_enc(void *self , GLuint pipeline)
9094 {
9095
9096         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9097         IOStream *stream = ctx->m_stream;
9098         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9099         bool useChecksum = checksumCalculator->getVersion() > 0;
9100
9101          unsigned char *ptr;
9102          unsigned char *buf;
9103          const size_t sizeWithoutChecksum = 8 + 4;
9104          const size_t checksumSize = checksumCalculator->checksumByteSize();
9105          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9106         buf = stream->alloc(totalSize);
9107         ptr = buf;
9108         int tmp = OP_glValidateProgramPipeline;memcpy(ptr, &tmp, 4); ptr += 4;
9109         memcpy(ptr, &totalSize, 4);  ptr += 4;
9110
9111                 memcpy(ptr, &pipeline, 4); ptr += 4;
9112
9113         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9114         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9115
9116 }
9117
9118 GLboolean glIsProgramPipeline_enc(void *self , GLuint pipeline)
9119 {
9120
9121         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9122         IOStream *stream = ctx->m_stream;
9123         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9124         bool useChecksum = checksumCalculator->getVersion() > 0;
9125
9126          unsigned char *ptr;
9127          unsigned char *buf;
9128          const size_t sizeWithoutChecksum = 8 + 4;
9129          const size_t checksumSize = checksumCalculator->checksumByteSize();
9130          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9131         buf = stream->alloc(totalSize);
9132         ptr = buf;
9133         int tmp = OP_glIsProgramPipeline;memcpy(ptr, &tmp, 4); ptr += 4;
9134         memcpy(ptr, &totalSize, 4);  ptr += 4;
9135
9136                 memcpy(ptr, &pipeline, 4); ptr += 4;
9137
9138         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9139         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9140
9141
9142         GLboolean retval;
9143         stream->readback(&retval, 1);
9144         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
9145         if (useChecksum) {
9146                 unsigned char *checksumBufPtr = NULL;
9147                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
9148                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
9149                 stream->readback(checksumBufPtr, checksumSize);
9150                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
9151                         ALOGE("glIsProgramPipeline: GL communication error, please report this issue to b.android.com.\n");
9152                         abort();
9153                 }
9154         }
9155         return retval;
9156 }
9157
9158 void glUseProgramStages_enc(void *self , GLuint pipeline, GLbitfield stages, GLuint program)
9159 {
9160
9161         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9162         IOStream *stream = ctx->m_stream;
9163         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9164         bool useChecksum = checksumCalculator->getVersion() > 0;
9165
9166          unsigned char *ptr;
9167          unsigned char *buf;
9168          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
9169          const size_t checksumSize = checksumCalculator->checksumByteSize();
9170          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9171         buf = stream->alloc(totalSize);
9172         ptr = buf;
9173         int tmp = OP_glUseProgramStages;memcpy(ptr, &tmp, 4); ptr += 4;
9174         memcpy(ptr, &totalSize, 4);  ptr += 4;
9175
9176                 memcpy(ptr, &pipeline, 4); ptr += 4;
9177                 memcpy(ptr, &stages, 4); ptr += 4;
9178                 memcpy(ptr, &program, 4); ptr += 4;
9179
9180         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9181         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9182
9183 }
9184
9185 void glActiveShaderProgram_enc(void *self , GLuint pipeline, GLuint program)
9186 {
9187
9188         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9189         IOStream *stream = ctx->m_stream;
9190         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9191         bool useChecksum = checksumCalculator->getVersion() > 0;
9192
9193          unsigned char *ptr;
9194          unsigned char *buf;
9195          const size_t sizeWithoutChecksum = 8 + 4 + 4;
9196          const size_t checksumSize = checksumCalculator->checksumByteSize();
9197          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9198         buf = stream->alloc(totalSize);
9199         ptr = buf;
9200         int tmp = OP_glActiveShaderProgram;memcpy(ptr, &tmp, 4); ptr += 4;
9201         memcpy(ptr, &totalSize, 4);  ptr += 4;
9202
9203                 memcpy(ptr, &pipeline, 4); ptr += 4;
9204                 memcpy(ptr, &program, 4); ptr += 4;
9205
9206         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9207         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9208
9209 }
9210
9211 GLuint glCreateShaderProgramvAEMU_enc(void *self , GLenum type, GLsizei count, const char* packedStrings, GLuint packedLen)
9212 {
9213
9214         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9215         IOStream *stream = ctx->m_stream;
9216         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9217         bool useChecksum = checksumCalculator->getVersion() > 0;
9218
9219         const unsigned int __size_packedStrings =  packedLen;
9220          unsigned char *ptr;
9221          unsigned char *buf;
9222          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_packedStrings + 4 + 1*4;
9223          const size_t checksumSize = checksumCalculator->checksumByteSize();
9224          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9225         buf = stream->alloc(totalSize);
9226         ptr = buf;
9227         int tmp = OP_glCreateShaderProgramvAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
9228         memcpy(ptr, &totalSize, 4);  ptr += 4;
9229
9230                 memcpy(ptr, &type, 4); ptr += 4;
9231                 memcpy(ptr, &count, 4); ptr += 4;
9232         *(unsigned int *)(ptr) = __size_packedStrings; ptr += 4;
9233         memcpy(ptr, packedStrings, __size_packedStrings);ptr += __size_packedStrings;
9234                 memcpy(ptr, &packedLen, 4); ptr += 4;
9235
9236         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9237         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9238
9239
9240         GLuint retval;
9241         stream->readback(&retval, 4);
9242         if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
9243         if (useChecksum) {
9244                 unsigned char *checksumBufPtr = NULL;
9245                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
9246                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
9247                 stream->readback(checksumBufPtr, checksumSize);
9248                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
9249                         ALOGE("glCreateShaderProgramvAEMU: GL communication error, please report this issue to b.android.com.\n");
9250                         abort();
9251                 }
9252         }
9253         return retval;
9254 }
9255
9256 void glProgramUniform1f_enc(void *self , GLuint program, GLint location, GLfloat v0)
9257 {
9258
9259         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9260         IOStream *stream = ctx->m_stream;
9261         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9262         bool useChecksum = checksumCalculator->getVersion() > 0;
9263
9264          unsigned char *ptr;
9265          unsigned char *buf;
9266          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
9267          const size_t checksumSize = checksumCalculator->checksumByteSize();
9268          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9269         buf = stream->alloc(totalSize);
9270         ptr = buf;
9271         int tmp = OP_glProgramUniform1f;memcpy(ptr, &tmp, 4); ptr += 4;
9272         memcpy(ptr, &totalSize, 4);  ptr += 4;
9273
9274                 memcpy(ptr, &program, 4); ptr += 4;
9275                 memcpy(ptr, &location, 4); ptr += 4;
9276                 memcpy(ptr, &v0, 4); ptr += 4;
9277
9278         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9279         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9280
9281 }
9282
9283 void glProgramUniform2f_enc(void *self , GLuint program, GLint location, GLfloat v0, GLfloat v1)
9284 {
9285
9286         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9287         IOStream *stream = ctx->m_stream;
9288         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9289         bool useChecksum = checksumCalculator->getVersion() > 0;
9290
9291          unsigned char *ptr;
9292          unsigned char *buf;
9293          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
9294          const size_t checksumSize = checksumCalculator->checksumByteSize();
9295          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9296         buf = stream->alloc(totalSize);
9297         ptr = buf;
9298         int tmp = OP_glProgramUniform2f;memcpy(ptr, &tmp, 4); ptr += 4;
9299         memcpy(ptr, &totalSize, 4);  ptr += 4;
9300
9301                 memcpy(ptr, &program, 4); ptr += 4;
9302                 memcpy(ptr, &location, 4); ptr += 4;
9303                 memcpy(ptr, &v0, 4); ptr += 4;
9304                 memcpy(ptr, &v1, 4); ptr += 4;
9305
9306         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9307         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9308
9309 }
9310
9311 void glProgramUniform3f_enc(void *self , GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
9312 {
9313
9314         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9315         IOStream *stream = ctx->m_stream;
9316         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9317         bool useChecksum = checksumCalculator->getVersion() > 0;
9318
9319          unsigned char *ptr;
9320          unsigned char *buf;
9321          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
9322          const size_t checksumSize = checksumCalculator->checksumByteSize();
9323          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9324         buf = stream->alloc(totalSize);
9325         ptr = buf;
9326         int tmp = OP_glProgramUniform3f;memcpy(ptr, &tmp, 4); ptr += 4;
9327         memcpy(ptr, &totalSize, 4);  ptr += 4;
9328
9329                 memcpy(ptr, &program, 4); ptr += 4;
9330                 memcpy(ptr, &location, 4); ptr += 4;
9331                 memcpy(ptr, &v0, 4); ptr += 4;
9332                 memcpy(ptr, &v1, 4); ptr += 4;
9333                 memcpy(ptr, &v2, 4); ptr += 4;
9334
9335         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9336         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9337
9338 }
9339
9340 void glProgramUniform4f_enc(void *self , GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
9341 {
9342
9343         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9344         IOStream *stream = ctx->m_stream;
9345         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9346         bool useChecksum = checksumCalculator->getVersion() > 0;
9347
9348          unsigned char *ptr;
9349          unsigned char *buf;
9350          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4;
9351          const size_t checksumSize = checksumCalculator->checksumByteSize();
9352          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9353         buf = stream->alloc(totalSize);
9354         ptr = buf;
9355         int tmp = OP_glProgramUniform4f;memcpy(ptr, &tmp, 4); ptr += 4;
9356         memcpy(ptr, &totalSize, 4);  ptr += 4;
9357
9358                 memcpy(ptr, &program, 4); ptr += 4;
9359                 memcpy(ptr, &location, 4); ptr += 4;
9360                 memcpy(ptr, &v0, 4); ptr += 4;
9361                 memcpy(ptr, &v1, 4); ptr += 4;
9362                 memcpy(ptr, &v2, 4); ptr += 4;
9363                 memcpy(ptr, &v3, 4); ptr += 4;
9364
9365         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9366         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9367
9368 }
9369
9370 void glProgramUniform1i_enc(void *self , GLuint program, GLint location, GLint v0)
9371 {
9372
9373         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9374         IOStream *stream = ctx->m_stream;
9375         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9376         bool useChecksum = checksumCalculator->getVersion() > 0;
9377
9378          unsigned char *ptr;
9379          unsigned char *buf;
9380          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
9381          const size_t checksumSize = checksumCalculator->checksumByteSize();
9382          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9383         buf = stream->alloc(totalSize);
9384         ptr = buf;
9385         int tmp = OP_glProgramUniform1i;memcpy(ptr, &tmp, 4); ptr += 4;
9386         memcpy(ptr, &totalSize, 4);  ptr += 4;
9387
9388                 memcpy(ptr, &program, 4); ptr += 4;
9389                 memcpy(ptr, &location, 4); ptr += 4;
9390                 memcpy(ptr, &v0, 4); ptr += 4;
9391
9392         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9393         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9394
9395 }
9396
9397 void glProgramUniform2i_enc(void *self , GLuint program, GLint location, GLint v0, GLint v1)
9398 {
9399
9400         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9401         IOStream *stream = ctx->m_stream;
9402         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9403         bool useChecksum = checksumCalculator->getVersion() > 0;
9404
9405          unsigned char *ptr;
9406          unsigned char *buf;
9407          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
9408          const size_t checksumSize = checksumCalculator->checksumByteSize();
9409          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9410         buf = stream->alloc(totalSize);
9411         ptr = buf;
9412         int tmp = OP_glProgramUniform2i;memcpy(ptr, &tmp, 4); ptr += 4;
9413         memcpy(ptr, &totalSize, 4);  ptr += 4;
9414
9415                 memcpy(ptr, &program, 4); ptr += 4;
9416                 memcpy(ptr, &location, 4); ptr += 4;
9417                 memcpy(ptr, &v0, 4); ptr += 4;
9418                 memcpy(ptr, &v1, 4); ptr += 4;
9419
9420         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9421         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9422
9423 }
9424
9425 void glProgramUniform3i_enc(void *self , GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
9426 {
9427
9428         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9429         IOStream *stream = ctx->m_stream;
9430         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9431         bool useChecksum = checksumCalculator->getVersion() > 0;
9432
9433          unsigned char *ptr;
9434          unsigned char *buf;
9435          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
9436          const size_t checksumSize = checksumCalculator->checksumByteSize();
9437          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9438         buf = stream->alloc(totalSize);
9439         ptr = buf;
9440         int tmp = OP_glProgramUniform3i;memcpy(ptr, &tmp, 4); ptr += 4;
9441         memcpy(ptr, &totalSize, 4);  ptr += 4;
9442
9443                 memcpy(ptr, &program, 4); ptr += 4;
9444                 memcpy(ptr, &location, 4); ptr += 4;
9445                 memcpy(ptr, &v0, 4); ptr += 4;
9446                 memcpy(ptr, &v1, 4); ptr += 4;
9447                 memcpy(ptr, &v2, 4); ptr += 4;
9448
9449         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9450         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9451
9452 }
9453
9454 void glProgramUniform4i_enc(void *self , GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
9455 {
9456
9457         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9458         IOStream *stream = ctx->m_stream;
9459         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9460         bool useChecksum = checksumCalculator->getVersion() > 0;
9461
9462          unsigned char *ptr;
9463          unsigned char *buf;
9464          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4;
9465          const size_t checksumSize = checksumCalculator->checksumByteSize();
9466          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9467         buf = stream->alloc(totalSize);
9468         ptr = buf;
9469         int tmp = OP_glProgramUniform4i;memcpy(ptr, &tmp, 4); ptr += 4;
9470         memcpy(ptr, &totalSize, 4);  ptr += 4;
9471
9472                 memcpy(ptr, &program, 4); ptr += 4;
9473                 memcpy(ptr, &location, 4); ptr += 4;
9474                 memcpy(ptr, &v0, 4); ptr += 4;
9475                 memcpy(ptr, &v1, 4); ptr += 4;
9476                 memcpy(ptr, &v2, 4); ptr += 4;
9477                 memcpy(ptr, &v3, 4); ptr += 4;
9478
9479         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9480         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9481
9482 }
9483
9484 void glProgramUniform1ui_enc(void *self , GLuint program, GLint location, GLuint v0)
9485 {
9486
9487         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9488         IOStream *stream = ctx->m_stream;
9489         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9490         bool useChecksum = checksumCalculator->getVersion() > 0;
9491
9492          unsigned char *ptr;
9493          unsigned char *buf;
9494          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
9495          const size_t checksumSize = checksumCalculator->checksumByteSize();
9496          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9497         buf = stream->alloc(totalSize);
9498         ptr = buf;
9499         int tmp = OP_glProgramUniform1ui;memcpy(ptr, &tmp, 4); ptr += 4;
9500         memcpy(ptr, &totalSize, 4);  ptr += 4;
9501
9502                 memcpy(ptr, &program, 4); ptr += 4;
9503                 memcpy(ptr, &location, 4); ptr += 4;
9504                 memcpy(ptr, &v0, 4); ptr += 4;
9505
9506         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9507         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9508
9509 }
9510
9511 void glProgramUniform2ui_enc(void *self , GLuint program, GLint location, GLint v0, GLuint v1)
9512 {
9513
9514         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9515         IOStream *stream = ctx->m_stream;
9516         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9517         bool useChecksum = checksumCalculator->getVersion() > 0;
9518
9519          unsigned char *ptr;
9520          unsigned char *buf;
9521          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
9522          const size_t checksumSize = checksumCalculator->checksumByteSize();
9523          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9524         buf = stream->alloc(totalSize);
9525         ptr = buf;
9526         int tmp = OP_glProgramUniform2ui;memcpy(ptr, &tmp, 4); ptr += 4;
9527         memcpy(ptr, &totalSize, 4);  ptr += 4;
9528
9529                 memcpy(ptr, &program, 4); ptr += 4;
9530                 memcpy(ptr, &location, 4); ptr += 4;
9531                 memcpy(ptr, &v0, 4); ptr += 4;
9532                 memcpy(ptr, &v1, 4); ptr += 4;
9533
9534         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9535         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9536
9537 }
9538
9539 void glProgramUniform3ui_enc(void *self , GLuint program, GLint location, GLint v0, GLint v1, GLuint v2)
9540 {
9541
9542         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9543         IOStream *stream = ctx->m_stream;
9544         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9545         bool useChecksum = checksumCalculator->getVersion() > 0;
9546
9547          unsigned char *ptr;
9548          unsigned char *buf;
9549          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
9550          const size_t checksumSize = checksumCalculator->checksumByteSize();
9551          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9552         buf = stream->alloc(totalSize);
9553         ptr = buf;
9554         int tmp = OP_glProgramUniform3ui;memcpy(ptr, &tmp, 4); ptr += 4;
9555         memcpy(ptr, &totalSize, 4);  ptr += 4;
9556
9557                 memcpy(ptr, &program, 4); ptr += 4;
9558                 memcpy(ptr, &location, 4); ptr += 4;
9559                 memcpy(ptr, &v0, 4); ptr += 4;
9560                 memcpy(ptr, &v1, 4); ptr += 4;
9561                 memcpy(ptr, &v2, 4); ptr += 4;
9562
9563         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9564         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9565
9566 }
9567
9568 void glProgramUniform4ui_enc(void *self , GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLuint v3)
9569 {
9570
9571         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9572         IOStream *stream = ctx->m_stream;
9573         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9574         bool useChecksum = checksumCalculator->getVersion() > 0;
9575
9576          unsigned char *ptr;
9577          unsigned char *buf;
9578          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4;
9579          const size_t checksumSize = checksumCalculator->checksumByteSize();
9580          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9581         buf = stream->alloc(totalSize);
9582         ptr = buf;
9583         int tmp = OP_glProgramUniform4ui;memcpy(ptr, &tmp, 4); ptr += 4;
9584         memcpy(ptr, &totalSize, 4);  ptr += 4;
9585
9586                 memcpy(ptr, &program, 4); ptr += 4;
9587                 memcpy(ptr, &location, 4); ptr += 4;
9588                 memcpy(ptr, &v0, 4); ptr += 4;
9589                 memcpy(ptr, &v1, 4); ptr += 4;
9590                 memcpy(ptr, &v2, 4); ptr += 4;
9591                 memcpy(ptr, &v3, 4); ptr += 4;
9592
9593         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9594         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9595
9596 }
9597
9598 void glProgramUniform1fv_enc(void *self , GLuint program, GLint location, GLsizei count, const GLfloat* value)
9599 {
9600
9601         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9602         IOStream *stream = ctx->m_stream;
9603         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9604         bool useChecksum = checksumCalculator->getVersion() > 0;
9605
9606         const unsigned int __size_value =  (count * sizeof(GLfloat));
9607          unsigned char *ptr;
9608          unsigned char *buf;
9609          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_value + 1*4;
9610          const size_t checksumSize = checksumCalculator->checksumByteSize();
9611          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9612         buf = stream->alloc(totalSize);
9613         ptr = buf;
9614         int tmp = OP_glProgramUniform1fv;memcpy(ptr, &tmp, 4); ptr += 4;
9615         memcpy(ptr, &totalSize, 4);  ptr += 4;
9616
9617                 memcpy(ptr, &program, 4); ptr += 4;
9618                 memcpy(ptr, &location, 4); ptr += 4;
9619                 memcpy(ptr, &count, 4); ptr += 4;
9620         *(unsigned int *)(ptr) = __size_value; ptr += 4;
9621         memcpy(ptr, value, __size_value);ptr += __size_value;
9622
9623         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9624         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9625
9626 }
9627
9628 void glProgramUniform2fv_enc(void *self , GLuint program, GLint location, GLsizei count, const GLfloat* value)
9629 {
9630
9631         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9632         IOStream *stream = ctx->m_stream;
9633         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9634         bool useChecksum = checksumCalculator->getVersion() > 0;
9635
9636         const unsigned int __size_value =  (count * 2 * sizeof(GLfloat));
9637          unsigned char *ptr;
9638          unsigned char *buf;
9639          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_value + 1*4;
9640          const size_t checksumSize = checksumCalculator->checksumByteSize();
9641          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9642         buf = stream->alloc(totalSize);
9643         ptr = buf;
9644         int tmp = OP_glProgramUniform2fv;memcpy(ptr, &tmp, 4); ptr += 4;
9645         memcpy(ptr, &totalSize, 4);  ptr += 4;
9646
9647                 memcpy(ptr, &program, 4); ptr += 4;
9648                 memcpy(ptr, &location, 4); ptr += 4;
9649                 memcpy(ptr, &count, 4); ptr += 4;
9650         *(unsigned int *)(ptr) = __size_value; ptr += 4;
9651         memcpy(ptr, value, __size_value);ptr += __size_value;
9652
9653         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9654         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9655
9656 }
9657
9658 void glProgramUniform3fv_enc(void *self , GLuint program, GLint location, GLsizei count, const GLfloat* value)
9659 {
9660
9661         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9662         IOStream *stream = ctx->m_stream;
9663         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9664         bool useChecksum = checksumCalculator->getVersion() > 0;
9665
9666         const unsigned int __size_value =  (count * 3 * sizeof(GLfloat));
9667          unsigned char *ptr;
9668          unsigned char *buf;
9669          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_value + 1*4;
9670          const size_t checksumSize = checksumCalculator->checksumByteSize();
9671          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9672         buf = stream->alloc(totalSize);
9673         ptr = buf;
9674         int tmp = OP_glProgramUniform3fv;memcpy(ptr, &tmp, 4); ptr += 4;
9675         memcpy(ptr, &totalSize, 4);  ptr += 4;
9676
9677                 memcpy(ptr, &program, 4); ptr += 4;
9678                 memcpy(ptr, &location, 4); ptr += 4;
9679                 memcpy(ptr, &count, 4); ptr += 4;
9680         *(unsigned int *)(ptr) = __size_value; ptr += 4;
9681         memcpy(ptr, value, __size_value);ptr += __size_value;
9682
9683         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9684         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9685
9686 }
9687
9688 void glProgramUniform4fv_enc(void *self , GLuint program, GLint location, GLsizei count, const GLfloat* value)
9689 {
9690
9691         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9692         IOStream *stream = ctx->m_stream;
9693         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9694         bool useChecksum = checksumCalculator->getVersion() > 0;
9695
9696         const unsigned int __size_value =  (count * 4 * sizeof(GLfloat));
9697          unsigned char *ptr;
9698          unsigned char *buf;
9699          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_value + 1*4;
9700          const size_t checksumSize = checksumCalculator->checksumByteSize();
9701          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9702         buf = stream->alloc(totalSize);
9703         ptr = buf;
9704         int tmp = OP_glProgramUniform4fv;memcpy(ptr, &tmp, 4); ptr += 4;
9705         memcpy(ptr, &totalSize, 4);  ptr += 4;
9706
9707                 memcpy(ptr, &program, 4); ptr += 4;
9708                 memcpy(ptr, &location, 4); ptr += 4;
9709                 memcpy(ptr, &count, 4); ptr += 4;
9710         *(unsigned int *)(ptr) = __size_value; ptr += 4;
9711         memcpy(ptr, value, __size_value);ptr += __size_value;
9712
9713         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9714         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9715
9716 }
9717
9718 void glProgramUniform1iv_enc(void *self , GLuint program, GLint location, GLsizei count, const GLint* value)
9719 {
9720
9721         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9722         IOStream *stream = ctx->m_stream;
9723         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9724         bool useChecksum = checksumCalculator->getVersion() > 0;
9725
9726         const unsigned int __size_value =  (count * sizeof(GLint));
9727          unsigned char *ptr;
9728          unsigned char *buf;
9729          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_value + 1*4;
9730          const size_t checksumSize = checksumCalculator->checksumByteSize();
9731          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9732         buf = stream->alloc(totalSize);
9733         ptr = buf;
9734         int tmp = OP_glProgramUniform1iv;memcpy(ptr, &tmp, 4); ptr += 4;
9735         memcpy(ptr, &totalSize, 4);  ptr += 4;
9736
9737                 memcpy(ptr, &program, 4); ptr += 4;
9738                 memcpy(ptr, &location, 4); ptr += 4;
9739                 memcpy(ptr, &count, 4); ptr += 4;
9740         *(unsigned int *)(ptr) = __size_value; ptr += 4;
9741         memcpy(ptr, value, __size_value);ptr += __size_value;
9742
9743         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9744         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9745
9746 }
9747
9748 void glProgramUniform2iv_enc(void *self , GLuint program, GLint location, GLsizei count, const GLint* value)
9749 {
9750
9751         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9752         IOStream *stream = ctx->m_stream;
9753         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9754         bool useChecksum = checksumCalculator->getVersion() > 0;
9755
9756         const unsigned int __size_value =  (count * 2 * sizeof(GLint));
9757          unsigned char *ptr;
9758          unsigned char *buf;
9759          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_value + 1*4;
9760          const size_t checksumSize = checksumCalculator->checksumByteSize();
9761          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9762         buf = stream->alloc(totalSize);
9763         ptr = buf;
9764         int tmp = OP_glProgramUniform2iv;memcpy(ptr, &tmp, 4); ptr += 4;
9765         memcpy(ptr, &totalSize, 4);  ptr += 4;
9766
9767                 memcpy(ptr, &program, 4); ptr += 4;
9768                 memcpy(ptr, &location, 4); ptr += 4;
9769                 memcpy(ptr, &count, 4); ptr += 4;
9770         *(unsigned int *)(ptr) = __size_value; ptr += 4;
9771         memcpy(ptr, value, __size_value);ptr += __size_value;
9772
9773         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9774         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9775
9776 }
9777
9778 void glProgramUniform3iv_enc(void *self , GLuint program, GLint location, GLsizei count, const GLint* value)
9779 {
9780
9781         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9782         IOStream *stream = ctx->m_stream;
9783         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9784         bool useChecksum = checksumCalculator->getVersion() > 0;
9785
9786         const unsigned int __size_value =  (count * 3 * sizeof(GLint));
9787          unsigned char *ptr;
9788          unsigned char *buf;
9789          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_value + 1*4;
9790          const size_t checksumSize = checksumCalculator->checksumByteSize();
9791          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9792         buf = stream->alloc(totalSize);
9793         ptr = buf;
9794         int tmp = OP_glProgramUniform3iv;memcpy(ptr, &tmp, 4); ptr += 4;
9795         memcpy(ptr, &totalSize, 4);  ptr += 4;
9796
9797                 memcpy(ptr, &program, 4); ptr += 4;
9798                 memcpy(ptr, &location, 4); ptr += 4;
9799                 memcpy(ptr, &count, 4); ptr += 4;
9800         *(unsigned int *)(ptr) = __size_value; ptr += 4;
9801         memcpy(ptr, value, __size_value);ptr += __size_value;
9802
9803         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9804         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9805
9806 }
9807
9808 void glProgramUniform4iv_enc(void *self , GLuint program, GLint location, GLsizei count, const GLint* value)
9809 {
9810
9811         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9812         IOStream *stream = ctx->m_stream;
9813         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9814         bool useChecksum = checksumCalculator->getVersion() > 0;
9815
9816         const unsigned int __size_value =  (count * 4 * sizeof(GLint));
9817          unsigned char *ptr;
9818          unsigned char *buf;
9819          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_value + 1*4;
9820          const size_t checksumSize = checksumCalculator->checksumByteSize();
9821          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9822         buf = stream->alloc(totalSize);
9823         ptr = buf;
9824         int tmp = OP_glProgramUniform4iv;memcpy(ptr, &tmp, 4); ptr += 4;
9825         memcpy(ptr, &totalSize, 4);  ptr += 4;
9826
9827                 memcpy(ptr, &program, 4); ptr += 4;
9828                 memcpy(ptr, &location, 4); ptr += 4;
9829                 memcpy(ptr, &count, 4); ptr += 4;
9830         *(unsigned int *)(ptr) = __size_value; ptr += 4;
9831         memcpy(ptr, value, __size_value);ptr += __size_value;
9832
9833         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9834         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9835
9836 }
9837
9838 void glProgramUniform1uiv_enc(void *self , GLuint program, GLint location, GLsizei count, const GLuint* value)
9839 {
9840
9841         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9842         IOStream *stream = ctx->m_stream;
9843         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9844         bool useChecksum = checksumCalculator->getVersion() > 0;
9845
9846         const unsigned int __size_value =  (count * sizeof(GLuint));
9847          unsigned char *ptr;
9848          unsigned char *buf;
9849          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_value + 1*4;
9850          const size_t checksumSize = checksumCalculator->checksumByteSize();
9851          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9852         buf = stream->alloc(totalSize);
9853         ptr = buf;
9854         int tmp = OP_glProgramUniform1uiv;memcpy(ptr, &tmp, 4); ptr += 4;
9855         memcpy(ptr, &totalSize, 4);  ptr += 4;
9856
9857                 memcpy(ptr, &program, 4); ptr += 4;
9858                 memcpy(ptr, &location, 4); ptr += 4;
9859                 memcpy(ptr, &count, 4); ptr += 4;
9860         *(unsigned int *)(ptr) = __size_value; ptr += 4;
9861         memcpy(ptr, value, __size_value);ptr += __size_value;
9862
9863         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9864         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9865
9866 }
9867
9868 void glProgramUniform2uiv_enc(void *self , GLuint program, GLint location, GLsizei count, const GLuint* value)
9869 {
9870
9871         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9872         IOStream *stream = ctx->m_stream;
9873         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9874         bool useChecksum = checksumCalculator->getVersion() > 0;
9875
9876         const unsigned int __size_value =  (count * 2 * sizeof(GLuint));
9877          unsigned char *ptr;
9878          unsigned char *buf;
9879          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_value + 1*4;
9880          const size_t checksumSize = checksumCalculator->checksumByteSize();
9881          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9882         buf = stream->alloc(totalSize);
9883         ptr = buf;
9884         int tmp = OP_glProgramUniform2uiv;memcpy(ptr, &tmp, 4); ptr += 4;
9885         memcpy(ptr, &totalSize, 4);  ptr += 4;
9886
9887                 memcpy(ptr, &program, 4); ptr += 4;
9888                 memcpy(ptr, &location, 4); ptr += 4;
9889                 memcpy(ptr, &count, 4); ptr += 4;
9890         *(unsigned int *)(ptr) = __size_value; ptr += 4;
9891         memcpy(ptr, value, __size_value);ptr += __size_value;
9892
9893         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9894         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9895
9896 }
9897
9898 void glProgramUniform3uiv_enc(void *self , GLuint program, GLint location, GLsizei count, const GLuint* value)
9899 {
9900
9901         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9902         IOStream *stream = ctx->m_stream;
9903         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9904         bool useChecksum = checksumCalculator->getVersion() > 0;
9905
9906         const unsigned int __size_value =  (count * 3 * sizeof(GLuint));
9907          unsigned char *ptr;
9908          unsigned char *buf;
9909          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_value + 1*4;
9910          const size_t checksumSize = checksumCalculator->checksumByteSize();
9911          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9912         buf = stream->alloc(totalSize);
9913         ptr = buf;
9914         int tmp = OP_glProgramUniform3uiv;memcpy(ptr, &tmp, 4); ptr += 4;
9915         memcpy(ptr, &totalSize, 4);  ptr += 4;
9916
9917                 memcpy(ptr, &program, 4); ptr += 4;
9918                 memcpy(ptr, &location, 4); ptr += 4;
9919                 memcpy(ptr, &count, 4); ptr += 4;
9920         *(unsigned int *)(ptr) = __size_value; ptr += 4;
9921         memcpy(ptr, value, __size_value);ptr += __size_value;
9922
9923         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9924         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9925
9926 }
9927
9928 void glProgramUniform4uiv_enc(void *self , GLuint program, GLint location, GLsizei count, const GLuint* value)
9929 {
9930
9931         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9932         IOStream *stream = ctx->m_stream;
9933         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9934         bool useChecksum = checksumCalculator->getVersion() > 0;
9935
9936         const unsigned int __size_value =  (count * 4 * sizeof(GLuint));
9937          unsigned char *ptr;
9938          unsigned char *buf;
9939          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_value + 1*4;
9940          const size_t checksumSize = checksumCalculator->checksumByteSize();
9941          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9942         buf = stream->alloc(totalSize);
9943         ptr = buf;
9944         int tmp = OP_glProgramUniform4uiv;memcpy(ptr, &tmp, 4); ptr += 4;
9945         memcpy(ptr, &totalSize, 4);  ptr += 4;
9946
9947                 memcpy(ptr, &program, 4); ptr += 4;
9948                 memcpy(ptr, &location, 4); ptr += 4;
9949                 memcpy(ptr, &count, 4); ptr += 4;
9950         *(unsigned int *)(ptr) = __size_value; ptr += 4;
9951         memcpy(ptr, value, __size_value);ptr += __size_value;
9952
9953         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9954         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9955
9956 }
9957
9958 void glProgramUniformMatrix2fv_enc(void *self , GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
9959 {
9960
9961         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9962         IOStream *stream = ctx->m_stream;
9963         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9964         bool useChecksum = checksumCalculator->getVersion() > 0;
9965
9966         const unsigned int __size_value =  (count * 4 * sizeof(GLfloat));
9967          unsigned char *ptr;
9968          unsigned char *buf;
9969          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 1 + __size_value + 1*4;
9970          const size_t checksumSize = checksumCalculator->checksumByteSize();
9971          const size_t totalSize = sizeWithoutChecksum + checksumSize;
9972         buf = stream->alloc(totalSize);
9973         ptr = buf;
9974         int tmp = OP_glProgramUniformMatrix2fv;memcpy(ptr, &tmp, 4); ptr += 4;
9975         memcpy(ptr, &totalSize, 4);  ptr += 4;
9976
9977                 memcpy(ptr, &program, 4); ptr += 4;
9978                 memcpy(ptr, &location, 4); ptr += 4;
9979                 memcpy(ptr, &count, 4); ptr += 4;
9980                 memcpy(ptr, &transpose, 1); ptr += 1;
9981         *(unsigned int *)(ptr) = __size_value; ptr += 4;
9982         memcpy(ptr, value, __size_value);ptr += __size_value;
9983
9984         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
9985         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
9986
9987 }
9988
9989 void glProgramUniformMatrix3fv_enc(void *self , GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
9990 {
9991
9992         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
9993         IOStream *stream = ctx->m_stream;
9994         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
9995         bool useChecksum = checksumCalculator->getVersion() > 0;
9996
9997         const unsigned int __size_value =  (count * 9 * sizeof(GLfloat));
9998          unsigned char *ptr;
9999          unsigned char *buf;
10000          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 1 + __size_value + 1*4;
10001          const size_t checksumSize = checksumCalculator->checksumByteSize();
10002          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10003         buf = stream->alloc(totalSize);
10004         ptr = buf;
10005         int tmp = OP_glProgramUniformMatrix3fv;memcpy(ptr, &tmp, 4); ptr += 4;
10006         memcpy(ptr, &totalSize, 4);  ptr += 4;
10007
10008                 memcpy(ptr, &program, 4); ptr += 4;
10009                 memcpy(ptr, &location, 4); ptr += 4;
10010                 memcpy(ptr, &count, 4); ptr += 4;
10011                 memcpy(ptr, &transpose, 1); ptr += 1;
10012         *(unsigned int *)(ptr) = __size_value; ptr += 4;
10013         memcpy(ptr, value, __size_value);ptr += __size_value;
10014
10015         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10016         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10017
10018 }
10019
10020 void glProgramUniformMatrix4fv_enc(void *self , GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
10021 {
10022
10023         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10024         IOStream *stream = ctx->m_stream;
10025         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10026         bool useChecksum = checksumCalculator->getVersion() > 0;
10027
10028         const unsigned int __size_value =  (count * 16 * sizeof(GLfloat));
10029          unsigned char *ptr;
10030          unsigned char *buf;
10031          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 1 + __size_value + 1*4;
10032          const size_t checksumSize = checksumCalculator->checksumByteSize();
10033          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10034         buf = stream->alloc(totalSize);
10035         ptr = buf;
10036         int tmp = OP_glProgramUniformMatrix4fv;memcpy(ptr, &tmp, 4); ptr += 4;
10037         memcpy(ptr, &totalSize, 4);  ptr += 4;
10038
10039                 memcpy(ptr, &program, 4); ptr += 4;
10040                 memcpy(ptr, &location, 4); ptr += 4;
10041                 memcpy(ptr, &count, 4); ptr += 4;
10042                 memcpy(ptr, &transpose, 1); ptr += 1;
10043         *(unsigned int *)(ptr) = __size_value; ptr += 4;
10044         memcpy(ptr, value, __size_value);ptr += __size_value;
10045
10046         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10047         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10048
10049 }
10050
10051 void glProgramUniformMatrix2x3fv_enc(void *self , GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
10052 {
10053
10054         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10055         IOStream *stream = ctx->m_stream;
10056         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10057         bool useChecksum = checksumCalculator->getVersion() > 0;
10058
10059         const unsigned int __size_value =  (count * 6 * sizeof(GLfloat));
10060          unsigned char *ptr;
10061          unsigned char *buf;
10062          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 1 + __size_value + 1*4;
10063          const size_t checksumSize = checksumCalculator->checksumByteSize();
10064          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10065         buf = stream->alloc(totalSize);
10066         ptr = buf;
10067         int tmp = OP_glProgramUniformMatrix2x3fv;memcpy(ptr, &tmp, 4); ptr += 4;
10068         memcpy(ptr, &totalSize, 4);  ptr += 4;
10069
10070                 memcpy(ptr, &program, 4); ptr += 4;
10071                 memcpy(ptr, &location, 4); ptr += 4;
10072                 memcpy(ptr, &count, 4); ptr += 4;
10073                 memcpy(ptr, &transpose, 1); ptr += 1;
10074         *(unsigned int *)(ptr) = __size_value; ptr += 4;
10075         memcpy(ptr, value, __size_value);ptr += __size_value;
10076
10077         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10078         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10079
10080 }
10081
10082 void glProgramUniformMatrix3x2fv_enc(void *self , GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
10083 {
10084
10085         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10086         IOStream *stream = ctx->m_stream;
10087         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10088         bool useChecksum = checksumCalculator->getVersion() > 0;
10089
10090         const unsigned int __size_value =  (count * 6 * sizeof(GLfloat));
10091          unsigned char *ptr;
10092          unsigned char *buf;
10093          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 1 + __size_value + 1*4;
10094          const size_t checksumSize = checksumCalculator->checksumByteSize();
10095          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10096         buf = stream->alloc(totalSize);
10097         ptr = buf;
10098         int tmp = OP_glProgramUniformMatrix3x2fv;memcpy(ptr, &tmp, 4); ptr += 4;
10099         memcpy(ptr, &totalSize, 4);  ptr += 4;
10100
10101                 memcpy(ptr, &program, 4); ptr += 4;
10102                 memcpy(ptr, &location, 4); ptr += 4;
10103                 memcpy(ptr, &count, 4); ptr += 4;
10104                 memcpy(ptr, &transpose, 1); ptr += 1;
10105         *(unsigned int *)(ptr) = __size_value; ptr += 4;
10106         memcpy(ptr, value, __size_value);ptr += __size_value;
10107
10108         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10109         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10110
10111 }
10112
10113 void glProgramUniformMatrix2x4fv_enc(void *self , GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
10114 {
10115
10116         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10117         IOStream *stream = ctx->m_stream;
10118         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10119         bool useChecksum = checksumCalculator->getVersion() > 0;
10120
10121         const unsigned int __size_value =  (count * 8 * sizeof(GLfloat));
10122          unsigned char *ptr;
10123          unsigned char *buf;
10124          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 1 + __size_value + 1*4;
10125          const size_t checksumSize = checksumCalculator->checksumByteSize();
10126          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10127         buf = stream->alloc(totalSize);
10128         ptr = buf;
10129         int tmp = OP_glProgramUniformMatrix2x4fv;memcpy(ptr, &tmp, 4); ptr += 4;
10130         memcpy(ptr, &totalSize, 4);  ptr += 4;
10131
10132                 memcpy(ptr, &program, 4); ptr += 4;
10133                 memcpy(ptr, &location, 4); ptr += 4;
10134                 memcpy(ptr, &count, 4); ptr += 4;
10135                 memcpy(ptr, &transpose, 1); ptr += 1;
10136         *(unsigned int *)(ptr) = __size_value; ptr += 4;
10137         memcpy(ptr, value, __size_value);ptr += __size_value;
10138
10139         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10140         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10141
10142 }
10143
10144 void glProgramUniformMatrix4x2fv_enc(void *self , GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
10145 {
10146
10147         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10148         IOStream *stream = ctx->m_stream;
10149         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10150         bool useChecksum = checksumCalculator->getVersion() > 0;
10151
10152         const unsigned int __size_value =  (count * 8 * sizeof(GLfloat));
10153          unsigned char *ptr;
10154          unsigned char *buf;
10155          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 1 + __size_value + 1*4;
10156          const size_t checksumSize = checksumCalculator->checksumByteSize();
10157          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10158         buf = stream->alloc(totalSize);
10159         ptr = buf;
10160         int tmp = OP_glProgramUniformMatrix4x2fv;memcpy(ptr, &tmp, 4); ptr += 4;
10161         memcpy(ptr, &totalSize, 4);  ptr += 4;
10162
10163                 memcpy(ptr, &program, 4); ptr += 4;
10164                 memcpy(ptr, &location, 4); ptr += 4;
10165                 memcpy(ptr, &count, 4); ptr += 4;
10166                 memcpy(ptr, &transpose, 1); ptr += 1;
10167         *(unsigned int *)(ptr) = __size_value; ptr += 4;
10168         memcpy(ptr, value, __size_value);ptr += __size_value;
10169
10170         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10171         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10172
10173 }
10174
10175 void glProgramUniformMatrix3x4fv_enc(void *self , GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
10176 {
10177
10178         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10179         IOStream *stream = ctx->m_stream;
10180         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10181         bool useChecksum = checksumCalculator->getVersion() > 0;
10182
10183         const unsigned int __size_value =  (count * 12 * sizeof(GLfloat));
10184          unsigned char *ptr;
10185          unsigned char *buf;
10186          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 1 + __size_value + 1*4;
10187          const size_t checksumSize = checksumCalculator->checksumByteSize();
10188          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10189         buf = stream->alloc(totalSize);
10190         ptr = buf;
10191         int tmp = OP_glProgramUniformMatrix3x4fv;memcpy(ptr, &tmp, 4); ptr += 4;
10192         memcpy(ptr, &totalSize, 4);  ptr += 4;
10193
10194                 memcpy(ptr, &program, 4); ptr += 4;
10195                 memcpy(ptr, &location, 4); ptr += 4;
10196                 memcpy(ptr, &count, 4); ptr += 4;
10197                 memcpy(ptr, &transpose, 1); ptr += 1;
10198         *(unsigned int *)(ptr) = __size_value; ptr += 4;
10199         memcpy(ptr, value, __size_value);ptr += __size_value;
10200
10201         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10202         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10203
10204 }
10205
10206 void glProgramUniformMatrix4x3fv_enc(void *self , GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
10207 {
10208
10209         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10210         IOStream *stream = ctx->m_stream;
10211         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10212         bool useChecksum = checksumCalculator->getVersion() > 0;
10213
10214         const unsigned int __size_value =  (count * 12 * sizeof(GLfloat));
10215          unsigned char *ptr;
10216          unsigned char *buf;
10217          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 1 + __size_value + 1*4;
10218          const size_t checksumSize = checksumCalculator->checksumByteSize();
10219          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10220         buf = stream->alloc(totalSize);
10221         ptr = buf;
10222         int tmp = OP_glProgramUniformMatrix4x3fv;memcpy(ptr, &tmp, 4); ptr += 4;
10223         memcpy(ptr, &totalSize, 4);  ptr += 4;
10224
10225                 memcpy(ptr, &program, 4); ptr += 4;
10226                 memcpy(ptr, &location, 4); ptr += 4;
10227                 memcpy(ptr, &count, 4); ptr += 4;
10228                 memcpy(ptr, &transpose, 1); ptr += 1;
10229         *(unsigned int *)(ptr) = __size_value; ptr += 4;
10230         memcpy(ptr, value, __size_value);ptr += __size_value;
10231
10232         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10233         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10234
10235 }
10236
10237 void glGetProgramInterfaceiv_enc(void *self , GLuint program, GLenum programInterface, GLenum pname, GLint* params)
10238 {
10239
10240         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10241         IOStream *stream = ctx->m_stream;
10242         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10243         bool useChecksum = checksumCalculator->getVersion() > 0;
10244
10245         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
10246          unsigned char *ptr;
10247          unsigned char *buf;
10248          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 0 + 1*4;
10249          const size_t checksumSize = checksumCalculator->checksumByteSize();
10250          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10251         buf = stream->alloc(totalSize);
10252         ptr = buf;
10253         int tmp = OP_glGetProgramInterfaceiv;memcpy(ptr, &tmp, 4); ptr += 4;
10254         memcpy(ptr, &totalSize, 4);  ptr += 4;
10255
10256                 memcpy(ptr, &program, 4); ptr += 4;
10257                 memcpy(ptr, &programInterface, 4); ptr += 4;
10258                 memcpy(ptr, &pname, 4); ptr += 4;
10259         *(unsigned int *)(ptr) = __size_params; ptr += 4;
10260
10261         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10262         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10263
10264         stream->readback(params, __size_params);
10265         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
10266         if (useChecksum) {
10267                 unsigned char *checksumBufPtr = NULL;
10268                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
10269                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
10270                 stream->readback(checksumBufPtr, checksumSize);
10271                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
10272                         ALOGE("glGetProgramInterfaceiv: GL communication error, please report this issue to b.android.com.\n");
10273                         abort();
10274                 }
10275         }
10276 }
10277
10278 void glGetProgramResourceiv_enc(void *self , GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params)
10279 {
10280
10281         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10282         IOStream *stream = ctx->m_stream;
10283         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10284         bool useChecksum = checksumCalculator->getVersion() > 0;
10285
10286         const unsigned int __size_props =  (propCount * sizeof(GLenum));
10287         const unsigned int __size_length = ((length != NULL) ?  (sizeof(GLsizei)) : 0);
10288         const unsigned int __size_params =  (bufSize * sizeof(GLint));
10289          unsigned char *ptr;
10290          unsigned char *buf;
10291          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + __size_props + 4 + 0 + 0 + 3*4;
10292          const size_t checksumSize = checksumCalculator->checksumByteSize();
10293          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10294         buf = stream->alloc(totalSize);
10295         ptr = buf;
10296         int tmp = OP_glGetProgramResourceiv;memcpy(ptr, &tmp, 4); ptr += 4;
10297         memcpy(ptr, &totalSize, 4);  ptr += 4;
10298
10299                 memcpy(ptr, &program, 4); ptr += 4;
10300                 memcpy(ptr, &programInterface, 4); ptr += 4;
10301                 memcpy(ptr, &index, 4); ptr += 4;
10302                 memcpy(ptr, &propCount, 4); ptr += 4;
10303         *(unsigned int *)(ptr) = __size_props; ptr += 4;
10304         memcpy(ptr, props, __size_props);ptr += __size_props;
10305                 memcpy(ptr, &bufSize, 4); ptr += 4;
10306         *(unsigned int *)(ptr) = __size_length; ptr += 4;
10307         *(unsigned int *)(ptr) = __size_params; ptr += 4;
10308
10309         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10310         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10311
10312         if (length != NULL) {
10313                 stream->readback(length, __size_length);
10314                 if (useChecksum) checksumCalculator->addBuffer(length, __size_length);
10315         }
10316         stream->readback(params, __size_params);
10317         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
10318         if (useChecksum) {
10319                 unsigned char *checksumBufPtr = NULL;
10320                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
10321                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
10322                 stream->readback(checksumBufPtr, checksumSize);
10323                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
10324                         ALOGE("glGetProgramResourceiv: GL communication error, please report this issue to b.android.com.\n");
10325                         abort();
10326                 }
10327         }
10328 }
10329
10330 GLuint glGetProgramResourceIndex_enc(void *self , GLuint program, GLenum programInterface, const char* name)
10331 {
10332
10333         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10334         IOStream *stream = ctx->m_stream;
10335         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10336         bool useChecksum = checksumCalculator->getVersion() > 0;
10337
10338         const unsigned int __size_name =  (strlen(name) + 1);
10339          unsigned char *ptr;
10340          unsigned char *buf;
10341          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_name + 1*4;
10342          const size_t checksumSize = checksumCalculator->checksumByteSize();
10343          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10344         buf = stream->alloc(totalSize);
10345         ptr = buf;
10346         int tmp = OP_glGetProgramResourceIndex;memcpy(ptr, &tmp, 4); ptr += 4;
10347         memcpy(ptr, &totalSize, 4);  ptr += 4;
10348
10349                 memcpy(ptr, &program, 4); ptr += 4;
10350                 memcpy(ptr, &programInterface, 4); ptr += 4;
10351         *(unsigned int *)(ptr) = __size_name; ptr += 4;
10352         memcpy(ptr, name, __size_name);ptr += __size_name;
10353
10354         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10355         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10356
10357
10358         GLuint retval;
10359         stream->readback(&retval, 4);
10360         if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
10361         if (useChecksum) {
10362                 unsigned char *checksumBufPtr = NULL;
10363                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
10364                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
10365                 stream->readback(checksumBufPtr, checksumSize);
10366                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
10367                         ALOGE("glGetProgramResourceIndex: GL communication error, please report this issue to b.android.com.\n");
10368                         abort();
10369                 }
10370         }
10371         return retval;
10372 }
10373
10374 GLint glGetProgramResourceLocation_enc(void *self , GLuint program, GLenum programInterface, const char* name)
10375 {
10376
10377         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10378         IOStream *stream = ctx->m_stream;
10379         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10380         bool useChecksum = checksumCalculator->getVersion() > 0;
10381
10382         const unsigned int __size_name =  (strlen(name) + 1);
10383          unsigned char *ptr;
10384          unsigned char *buf;
10385          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_name + 1*4;
10386          const size_t checksumSize = checksumCalculator->checksumByteSize();
10387          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10388         buf = stream->alloc(totalSize);
10389         ptr = buf;
10390         int tmp = OP_glGetProgramResourceLocation;memcpy(ptr, &tmp, 4); ptr += 4;
10391         memcpy(ptr, &totalSize, 4);  ptr += 4;
10392
10393                 memcpy(ptr, &program, 4); ptr += 4;
10394                 memcpy(ptr, &programInterface, 4); ptr += 4;
10395         *(unsigned int *)(ptr) = __size_name; ptr += 4;
10396         memcpy(ptr, name, __size_name);ptr += __size_name;
10397
10398         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10399         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10400
10401
10402         GLint retval;
10403         stream->readback(&retval, 4);
10404         if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
10405         if (useChecksum) {
10406                 unsigned char *checksumBufPtr = NULL;
10407                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
10408                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
10409                 stream->readback(checksumBufPtr, checksumSize);
10410                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
10411                         ALOGE("glGetProgramResourceLocation: GL communication error, please report this issue to b.android.com.\n");
10412                         abort();
10413                 }
10414         }
10415         return retval;
10416 }
10417
10418 void glGetProgramResourceName_enc(void *self , GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei* length, char* name)
10419 {
10420
10421         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10422         IOStream *stream = ctx->m_stream;
10423         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10424         bool useChecksum = checksumCalculator->getVersion() > 0;
10425
10426         const unsigned int __size_length = ((length != NULL) ?  (sizeof(GLsizei)) : 0);
10427         const unsigned int __size_name =  bufSize;
10428          unsigned char *ptr;
10429          unsigned char *buf;
10430          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 0 + 0 + 2*4;
10431          const size_t checksumSize = checksumCalculator->checksumByteSize();
10432          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10433         buf = stream->alloc(totalSize);
10434         ptr = buf;
10435         int tmp = OP_glGetProgramResourceName;memcpy(ptr, &tmp, 4); ptr += 4;
10436         memcpy(ptr, &totalSize, 4);  ptr += 4;
10437
10438                 memcpy(ptr, &program, 4); ptr += 4;
10439                 memcpy(ptr, &programInterface, 4); ptr += 4;
10440                 memcpy(ptr, &index, 4); ptr += 4;
10441                 memcpy(ptr, &bufSize, 4); ptr += 4;
10442         *(unsigned int *)(ptr) = __size_length; ptr += 4;
10443         *(unsigned int *)(ptr) = __size_name; ptr += 4;
10444
10445         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10446         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10447
10448         if (length != NULL) {
10449                 stream->readback(length, __size_length);
10450                 if (useChecksum) checksumCalculator->addBuffer(length, __size_length);
10451         }
10452         stream->readback(name, __size_name);
10453         if (useChecksum) checksumCalculator->addBuffer(name, __size_name);
10454         if (useChecksum) {
10455                 unsigned char *checksumBufPtr = NULL;
10456                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
10457                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
10458                 stream->readback(checksumBufPtr, checksumSize);
10459                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
10460                         ALOGE("glGetProgramResourceName: GL communication error, please report this issue to b.android.com.\n");
10461                         abort();
10462                 }
10463         }
10464 }
10465
10466 void glBindImageTexture_enc(void *self , GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
10467 {
10468
10469         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10470         IOStream *stream = ctx->m_stream;
10471         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10472         bool useChecksum = checksumCalculator->getVersion() > 0;
10473
10474          unsigned char *ptr;
10475          unsigned char *buf;
10476          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 1 + 4 + 4 + 4;
10477          const size_t checksumSize = checksumCalculator->checksumByteSize();
10478          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10479         buf = stream->alloc(totalSize);
10480         ptr = buf;
10481         int tmp = OP_glBindImageTexture;memcpy(ptr, &tmp, 4); ptr += 4;
10482         memcpy(ptr, &totalSize, 4);  ptr += 4;
10483
10484                 memcpy(ptr, &unit, 4); ptr += 4;
10485                 memcpy(ptr, &texture, 4); ptr += 4;
10486                 memcpy(ptr, &level, 4); ptr += 4;
10487                 memcpy(ptr, &layered, 1); ptr += 1;
10488                 memcpy(ptr, &layer, 4); ptr += 4;
10489                 memcpy(ptr, &access, 4); ptr += 4;
10490                 memcpy(ptr, &format, 4); ptr += 4;
10491
10492         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10493         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10494
10495 }
10496
10497 void glDispatchCompute_enc(void *self , GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
10498 {
10499
10500         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10501         IOStream *stream = ctx->m_stream;
10502         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10503         bool useChecksum = checksumCalculator->getVersion() > 0;
10504
10505          unsigned char *ptr;
10506          unsigned char *buf;
10507          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
10508          const size_t checksumSize = checksumCalculator->checksumByteSize();
10509          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10510         buf = stream->alloc(totalSize);
10511         ptr = buf;
10512         int tmp = OP_glDispatchCompute;memcpy(ptr, &tmp, 4); ptr += 4;
10513         memcpy(ptr, &totalSize, 4);  ptr += 4;
10514
10515                 memcpy(ptr, &num_groups_x, 4); ptr += 4;
10516                 memcpy(ptr, &num_groups_y, 4); ptr += 4;
10517                 memcpy(ptr, &num_groups_z, 4); ptr += 4;
10518
10519         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10520         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10521
10522 }
10523
10524 void glDispatchComputeIndirect_enc(void *self , GLintptr indirect)
10525 {
10526
10527         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10528         IOStream *stream = ctx->m_stream;
10529         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10530         bool useChecksum = checksumCalculator->getVersion() > 0;
10531
10532          unsigned char *ptr;
10533          unsigned char *buf;
10534          const size_t sizeWithoutChecksum = 8 + 4;
10535          const size_t checksumSize = checksumCalculator->checksumByteSize();
10536          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10537         buf = stream->alloc(totalSize);
10538         ptr = buf;
10539         int tmp = OP_glDispatchComputeIndirect;memcpy(ptr, &tmp, 4); ptr += 4;
10540         memcpy(ptr, &totalSize, 4);  ptr += 4;
10541
10542                 memcpy(ptr, &indirect, 4); ptr += 4;
10543
10544         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10545         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10546
10547 }
10548
10549 void glBindVertexBuffer_enc(void *self , GLuint bindingindex, GLuint buffer, GLintptr offset, GLintptr stride)
10550 {
10551
10552         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10553         IOStream *stream = ctx->m_stream;
10554         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10555         bool useChecksum = checksumCalculator->getVersion() > 0;
10556
10557          unsigned char *ptr;
10558          unsigned char *buf;
10559          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
10560          const size_t checksumSize = checksumCalculator->checksumByteSize();
10561          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10562         buf = stream->alloc(totalSize);
10563         ptr = buf;
10564         int tmp = OP_glBindVertexBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
10565         memcpy(ptr, &totalSize, 4);  ptr += 4;
10566
10567                 memcpy(ptr, &bindingindex, 4); ptr += 4;
10568                 memcpy(ptr, &buffer, 4); ptr += 4;
10569                 memcpy(ptr, &offset, 4); ptr += 4;
10570                 memcpy(ptr, &stride, 4); ptr += 4;
10571
10572         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10573         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10574
10575 }
10576
10577 void glVertexAttribBinding_enc(void *self , GLuint attribindex, GLuint bindingindex)
10578 {
10579
10580         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10581         IOStream *stream = ctx->m_stream;
10582         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10583         bool useChecksum = checksumCalculator->getVersion() > 0;
10584
10585          unsigned char *ptr;
10586          unsigned char *buf;
10587          const size_t sizeWithoutChecksum = 8 + 4 + 4;
10588          const size_t checksumSize = checksumCalculator->checksumByteSize();
10589          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10590         buf = stream->alloc(totalSize);
10591         ptr = buf;
10592         int tmp = OP_glVertexAttribBinding;memcpy(ptr, &tmp, 4); ptr += 4;
10593         memcpy(ptr, &totalSize, 4);  ptr += 4;
10594
10595                 memcpy(ptr, &attribindex, 4); ptr += 4;
10596                 memcpy(ptr, &bindingindex, 4); ptr += 4;
10597
10598         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10599         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10600
10601 }
10602
10603 void glVertexAttribFormat_enc(void *self , GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
10604 {
10605
10606         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10607         IOStream *stream = ctx->m_stream;
10608         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10609         bool useChecksum = checksumCalculator->getVersion() > 0;
10610
10611          unsigned char *ptr;
10612          unsigned char *buf;
10613          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 1 + 4;
10614          const size_t checksumSize = checksumCalculator->checksumByteSize();
10615          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10616         buf = stream->alloc(totalSize);
10617         ptr = buf;
10618         int tmp = OP_glVertexAttribFormat;memcpy(ptr, &tmp, 4); ptr += 4;
10619         memcpy(ptr, &totalSize, 4);  ptr += 4;
10620
10621                 memcpy(ptr, &attribindex, 4); ptr += 4;
10622                 memcpy(ptr, &size, 4); ptr += 4;
10623                 memcpy(ptr, &type, 4); ptr += 4;
10624                 memcpy(ptr, &normalized, 1); ptr += 1;
10625                 memcpy(ptr, &relativeoffset, 4); ptr += 4;
10626
10627         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10628         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10629
10630 }
10631
10632 void glVertexAttribIFormat_enc(void *self , GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
10633 {
10634
10635         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10636         IOStream *stream = ctx->m_stream;
10637         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10638         bool useChecksum = checksumCalculator->getVersion() > 0;
10639
10640          unsigned char *ptr;
10641          unsigned char *buf;
10642          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
10643          const size_t checksumSize = checksumCalculator->checksumByteSize();
10644          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10645         buf = stream->alloc(totalSize);
10646         ptr = buf;
10647         int tmp = OP_glVertexAttribIFormat;memcpy(ptr, &tmp, 4); ptr += 4;
10648         memcpy(ptr, &totalSize, 4);  ptr += 4;
10649
10650                 memcpy(ptr, &attribindex, 4); ptr += 4;
10651                 memcpy(ptr, &size, 4); ptr += 4;
10652                 memcpy(ptr, &type, 4); ptr += 4;
10653                 memcpy(ptr, &relativeoffset, 4); ptr += 4;
10654
10655         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10656         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10657
10658 }
10659
10660 void glVertexBindingDivisor_enc(void *self , GLuint bindingindex, GLuint divisor)
10661 {
10662
10663         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10664         IOStream *stream = ctx->m_stream;
10665         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10666         bool useChecksum = checksumCalculator->getVersion() > 0;
10667
10668          unsigned char *ptr;
10669          unsigned char *buf;
10670          const size_t sizeWithoutChecksum = 8 + 4 + 4;
10671          const size_t checksumSize = checksumCalculator->checksumByteSize();
10672          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10673         buf = stream->alloc(totalSize);
10674         ptr = buf;
10675         int tmp = OP_glVertexBindingDivisor;memcpy(ptr, &tmp, 4); ptr += 4;
10676         memcpy(ptr, &totalSize, 4);  ptr += 4;
10677
10678                 memcpy(ptr, &bindingindex, 4); ptr += 4;
10679                 memcpy(ptr, &divisor, 4); ptr += 4;
10680
10681         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10682         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10683
10684 }
10685
10686 void glDrawArraysIndirectDataAEMU_enc(void *self , GLenum mode, const void* indirect, GLuint datalen)
10687 {
10688
10689         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10690         IOStream *stream = ctx->m_stream;
10691         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10692         bool useChecksum = checksumCalculator->getVersion() > 0;
10693
10694         const unsigned int __size_indirect =  datalen;
10695          unsigned char *ptr;
10696          unsigned char *buf;
10697          const size_t sizeWithoutChecksum = 8 + 4 + __size_indirect + 4 + 1*4;
10698          const size_t checksumSize = checksumCalculator->checksumByteSize();
10699          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10700         buf = stream->alloc(totalSize);
10701         ptr = buf;
10702         int tmp = OP_glDrawArraysIndirectDataAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
10703         memcpy(ptr, &totalSize, 4);  ptr += 4;
10704
10705                 memcpy(ptr, &mode, 4); ptr += 4;
10706         *(unsigned int *)(ptr) = __size_indirect; ptr += 4;
10707         memcpy(ptr, indirect, __size_indirect);ptr += __size_indirect;
10708                 memcpy(ptr, &datalen, 4); ptr += 4;
10709
10710         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10711         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10712
10713 }
10714
10715 void glDrawArraysIndirectOffsetAEMU_enc(void *self , GLenum mode, GLuint offset)
10716 {
10717
10718         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10719         IOStream *stream = ctx->m_stream;
10720         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10721         bool useChecksum = checksumCalculator->getVersion() > 0;
10722
10723          unsigned char *ptr;
10724          unsigned char *buf;
10725          const size_t sizeWithoutChecksum = 8 + 4 + 4;
10726          const size_t checksumSize = checksumCalculator->checksumByteSize();
10727          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10728         buf = stream->alloc(totalSize);
10729         ptr = buf;
10730         int tmp = OP_glDrawArraysIndirectOffsetAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
10731         memcpy(ptr, &totalSize, 4);  ptr += 4;
10732
10733                 memcpy(ptr, &mode, 4); ptr += 4;
10734                 memcpy(ptr, &offset, 4); ptr += 4;
10735
10736         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10737         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10738
10739 }
10740
10741 void glDrawElementsIndirectDataAEMU_enc(void *self , GLenum mode, GLenum type, const void* indirect, GLuint datalen)
10742 {
10743
10744         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10745         IOStream *stream = ctx->m_stream;
10746         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10747         bool useChecksum = checksumCalculator->getVersion() > 0;
10748
10749         const unsigned int __size_indirect =  datalen;
10750          unsigned char *ptr;
10751          unsigned char *buf;
10752          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_indirect + 4 + 1*4;
10753          const size_t checksumSize = checksumCalculator->checksumByteSize();
10754          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10755         buf = stream->alloc(totalSize);
10756         ptr = buf;
10757         int tmp = OP_glDrawElementsIndirectDataAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
10758         memcpy(ptr, &totalSize, 4);  ptr += 4;
10759
10760                 memcpy(ptr, &mode, 4); ptr += 4;
10761                 memcpy(ptr, &type, 4); ptr += 4;
10762         *(unsigned int *)(ptr) = __size_indirect; ptr += 4;
10763         memcpy(ptr, indirect, __size_indirect);ptr += __size_indirect;
10764                 memcpy(ptr, &datalen, 4); ptr += 4;
10765
10766         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10767         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10768
10769 }
10770
10771 void glDrawElementsIndirectOffsetAEMU_enc(void *self , GLenum mode, GLenum type, GLuint offset)
10772 {
10773
10774         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10775         IOStream *stream = ctx->m_stream;
10776         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10777         bool useChecksum = checksumCalculator->getVersion() > 0;
10778
10779          unsigned char *ptr;
10780          unsigned char *buf;
10781          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
10782          const size_t checksumSize = checksumCalculator->checksumByteSize();
10783          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10784         buf = stream->alloc(totalSize);
10785         ptr = buf;
10786         int tmp = OP_glDrawElementsIndirectOffsetAEMU;memcpy(ptr, &tmp, 4); ptr += 4;
10787         memcpy(ptr, &totalSize, 4);  ptr += 4;
10788
10789                 memcpy(ptr, &mode, 4); ptr += 4;
10790                 memcpy(ptr, &type, 4); ptr += 4;
10791                 memcpy(ptr, &offset, 4); ptr += 4;
10792
10793         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10794         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10795
10796 }
10797
10798 void glTexStorage2DMultisample_enc(void *self , GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
10799 {
10800
10801         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10802         IOStream *stream = ctx->m_stream;
10803         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10804         bool useChecksum = checksumCalculator->getVersion() > 0;
10805
10806          unsigned char *ptr;
10807          unsigned char *buf;
10808          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 1;
10809          const size_t checksumSize = checksumCalculator->checksumByteSize();
10810          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10811         buf = stream->alloc(totalSize);
10812         ptr = buf;
10813         int tmp = OP_glTexStorage2DMultisample;memcpy(ptr, &tmp, 4); ptr += 4;
10814         memcpy(ptr, &totalSize, 4);  ptr += 4;
10815
10816                 memcpy(ptr, &target, 4); ptr += 4;
10817                 memcpy(ptr, &samples, 4); ptr += 4;
10818                 memcpy(ptr, &internalformat, 4); ptr += 4;
10819                 memcpy(ptr, &width, 4); ptr += 4;
10820                 memcpy(ptr, &height, 4); ptr += 4;
10821                 memcpy(ptr, &fixedsamplelocations, 1); ptr += 1;
10822
10823         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10824         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10825
10826 }
10827
10828 void glSampleMaski_enc(void *self , GLuint maskNumber, GLbitfield mask)
10829 {
10830
10831         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10832         IOStream *stream = ctx->m_stream;
10833         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10834         bool useChecksum = checksumCalculator->getVersion() > 0;
10835
10836          unsigned char *ptr;
10837          unsigned char *buf;
10838          const size_t sizeWithoutChecksum = 8 + 4 + 4;
10839          const size_t checksumSize = checksumCalculator->checksumByteSize();
10840          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10841         buf = stream->alloc(totalSize);
10842         ptr = buf;
10843         int tmp = OP_glSampleMaski;memcpy(ptr, &tmp, 4); ptr += 4;
10844         memcpy(ptr, &totalSize, 4);  ptr += 4;
10845
10846                 memcpy(ptr, &maskNumber, 4); ptr += 4;
10847                 memcpy(ptr, &mask, 4); ptr += 4;
10848
10849         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10850         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10851
10852 }
10853
10854 void glGetMultisamplefv_enc(void *self , GLenum pname, GLuint index, GLfloat* val)
10855 {
10856
10857         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10858         IOStream *stream = ctx->m_stream;
10859         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10860         bool useChecksum = checksumCalculator->getVersion() > 0;
10861
10862         const unsigned int __size_val =  (glUtilsParamSize(pname) * sizeof(GLfloat));
10863          unsigned char *ptr;
10864          unsigned char *buf;
10865          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
10866          const size_t checksumSize = checksumCalculator->checksumByteSize();
10867          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10868         buf = stream->alloc(totalSize);
10869         ptr = buf;
10870         int tmp = OP_glGetMultisamplefv;memcpy(ptr, &tmp, 4); ptr += 4;
10871         memcpy(ptr, &totalSize, 4);  ptr += 4;
10872
10873                 memcpy(ptr, &pname, 4); ptr += 4;
10874                 memcpy(ptr, &index, 4); ptr += 4;
10875         *(unsigned int *)(ptr) = __size_val; ptr += 4;
10876
10877         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10878         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10879
10880         stream->readback(val, __size_val);
10881         if (useChecksum) checksumCalculator->addBuffer(val, __size_val);
10882         if (useChecksum) {
10883                 unsigned char *checksumBufPtr = NULL;
10884                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
10885                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
10886                 stream->readback(checksumBufPtr, checksumSize);
10887                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
10888                         ALOGE("glGetMultisamplefv: GL communication error, please report this issue to b.android.com.\n");
10889                         abort();
10890                 }
10891         }
10892 }
10893
10894 void glFramebufferParameteri_enc(void *self , GLenum target, GLenum pname, GLint param)
10895 {
10896
10897         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10898         IOStream *stream = ctx->m_stream;
10899         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10900         bool useChecksum = checksumCalculator->getVersion() > 0;
10901
10902          unsigned char *ptr;
10903          unsigned char *buf;
10904          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
10905          const size_t checksumSize = checksumCalculator->checksumByteSize();
10906          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10907         buf = stream->alloc(totalSize);
10908         ptr = buf;
10909         int tmp = OP_glFramebufferParameteri;memcpy(ptr, &tmp, 4); ptr += 4;
10910         memcpy(ptr, &totalSize, 4);  ptr += 4;
10911
10912                 memcpy(ptr, &target, 4); ptr += 4;
10913                 memcpy(ptr, &pname, 4); ptr += 4;
10914                 memcpy(ptr, &param, 4); ptr += 4;
10915
10916         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10917         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10918
10919 }
10920
10921 void glGetFramebufferParameteriv_enc(void *self , GLenum target, GLenum pname, GLint* params)
10922 {
10923
10924         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10925         IOStream *stream = ctx->m_stream;
10926         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10927         bool useChecksum = checksumCalculator->getVersion() > 0;
10928
10929         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
10930          unsigned char *ptr;
10931          unsigned char *buf;
10932          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 0 + 1*4;
10933          const size_t checksumSize = checksumCalculator->checksumByteSize();
10934          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10935         buf = stream->alloc(totalSize);
10936         ptr = buf;
10937         int tmp = OP_glGetFramebufferParameteriv;memcpy(ptr, &tmp, 4); ptr += 4;
10938         memcpy(ptr, &totalSize, 4);  ptr += 4;
10939
10940                 memcpy(ptr, &target, 4); ptr += 4;
10941                 memcpy(ptr, &pname, 4); ptr += 4;
10942         *(unsigned int *)(ptr) = __size_params; ptr += 4;
10943
10944         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10945         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10946
10947         stream->readback(params, __size_params);
10948         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
10949         if (useChecksum) {
10950                 unsigned char *checksumBufPtr = NULL;
10951                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
10952                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
10953                 stream->readback(checksumBufPtr, checksumSize);
10954                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
10955                         ALOGE("glGetFramebufferParameteriv: GL communication error, please report this issue to b.android.com.\n");
10956                         abort();
10957                 }
10958         }
10959 }
10960
10961 void glGetTexLevelParameterfv_enc(void *self , GLenum target, GLint level, GLenum pname, GLfloat* params)
10962 {
10963
10964         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
10965         IOStream *stream = ctx->m_stream;
10966         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
10967         bool useChecksum = checksumCalculator->getVersion() > 0;
10968
10969         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
10970          unsigned char *ptr;
10971          unsigned char *buf;
10972          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 0 + 1*4;
10973          const size_t checksumSize = checksumCalculator->checksumByteSize();
10974          const size_t totalSize = sizeWithoutChecksum + checksumSize;
10975         buf = stream->alloc(totalSize);
10976         ptr = buf;
10977         int tmp = OP_glGetTexLevelParameterfv;memcpy(ptr, &tmp, 4); ptr += 4;
10978         memcpy(ptr, &totalSize, 4);  ptr += 4;
10979
10980                 memcpy(ptr, &target, 4); ptr += 4;
10981                 memcpy(ptr, &level, 4); ptr += 4;
10982                 memcpy(ptr, &pname, 4); ptr += 4;
10983         *(unsigned int *)(ptr) = __size_params; ptr += 4;
10984
10985         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
10986         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
10987
10988         stream->readback(params, __size_params);
10989         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
10990         if (useChecksum) {
10991                 unsigned char *checksumBufPtr = NULL;
10992                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
10993                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
10994                 stream->readback(checksumBufPtr, checksumSize);
10995                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
10996                         ALOGE("glGetTexLevelParameterfv: GL communication error, please report this issue to b.android.com.\n");
10997                         abort();
10998                 }
10999         }
11000 }
11001
11002 void glGetTexLevelParameteriv_enc(void *self , GLenum target, GLint level, GLenum pname, GLint* params)
11003 {
11004
11005         gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
11006         IOStream *stream = ctx->m_stream;
11007         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
11008         bool useChecksum = checksumCalculator->getVersion() > 0;
11009
11010         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
11011          unsigned char *ptr;
11012          unsigned char *buf;
11013          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 0 + 1*4;
11014          const size_t checksumSize = checksumCalculator->checksumByteSize();
11015          const size_t totalSize = sizeWithoutChecksum + checksumSize;
11016         buf = stream->alloc(totalSize);
11017         ptr = buf;
11018         int tmp = OP_glGetTexLevelParameteriv;memcpy(ptr, &tmp, 4); ptr += 4;
11019         memcpy(ptr, &totalSize, 4);  ptr += 4;
11020
11021                 memcpy(ptr, &target, 4); ptr += 4;
11022                 memcpy(ptr, &level, 4); ptr += 4;
11023                 memcpy(ptr, &pname, 4); ptr += 4;
11024         *(unsigned int *)(ptr) = __size_params; ptr += 4;
11025
11026         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
11027         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
11028
11029         stream->readback(params, __size_params);
11030         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
11031         if (useChecksum) {
11032                 unsigned char *checksumBufPtr = NULL;
11033                 unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
11034                 if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
11035                 stream->readback(checksumBufPtr, checksumSize);
11036                 if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
11037                         ALOGE("glGetTexLevelParameteriv: GL communication error, please report this issue to b.android.com.\n");
11038                         abort();
11039                 }
11040         }
11041 }
11042
11043 }  // namespace
11044
11045 gl2_encoder_context_t::gl2_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator)
11046 {
11047         m_stream = stream;
11048         m_checksumCalculator = checksumCalculator;
11049
11050         this->glActiveTexture = &glActiveTexture_enc;
11051         this->glAttachShader = &glAttachShader_enc;
11052         this->glBindAttribLocation = &glBindAttribLocation_enc;
11053         this->glBindBuffer = &glBindBuffer_enc;
11054         this->glBindFramebuffer = &glBindFramebuffer_enc;
11055         this->glBindRenderbuffer = &glBindRenderbuffer_enc;
11056         this->glBindTexture = &glBindTexture_enc;
11057         this->glBlendColor = &glBlendColor_enc;
11058         this->glBlendEquation = &glBlendEquation_enc;
11059         this->glBlendEquationSeparate = &glBlendEquationSeparate_enc;
11060         this->glBlendFunc = &glBlendFunc_enc;
11061         this->glBlendFuncSeparate = &glBlendFuncSeparate_enc;
11062         this->glBufferData = &glBufferData_enc;
11063         this->glBufferSubData = &glBufferSubData_enc;
11064         this->glCheckFramebufferStatus = &glCheckFramebufferStatus_enc;
11065         this->glClear = &glClear_enc;
11066         this->glClearColor = &glClearColor_enc;
11067         this->glClearDepthf = &glClearDepthf_enc;
11068         this->glClearStencil = &glClearStencil_enc;
11069         this->glColorMask = &glColorMask_enc;
11070         this->glCompileShader = &glCompileShader_enc;
11071         this->glCompressedTexImage2D = &glCompressedTexImage2D_enc;
11072         this->glCompressedTexSubImage2D = &glCompressedTexSubImage2D_enc;
11073         this->glCopyTexImage2D = &glCopyTexImage2D_enc;
11074         this->glCopyTexSubImage2D = &glCopyTexSubImage2D_enc;
11075         this->glCreateProgram = &glCreateProgram_enc;
11076         this->glCreateShader = &glCreateShader_enc;
11077         this->glCullFace = &glCullFace_enc;
11078         this->glDeleteBuffers = &glDeleteBuffers_enc;
11079         this->glDeleteFramebuffers = &glDeleteFramebuffers_enc;
11080         this->glDeleteProgram = &glDeleteProgram_enc;
11081         this->glDeleteRenderbuffers = &glDeleteRenderbuffers_enc;
11082         this->glDeleteShader = &glDeleteShader_enc;
11083         this->glDeleteTextures = &glDeleteTextures_enc;
11084         this->glDepthFunc = &glDepthFunc_enc;
11085         this->glDepthMask = &glDepthMask_enc;
11086         this->glDepthRangef = &glDepthRangef_enc;
11087         this->glDetachShader = &glDetachShader_enc;
11088         this->glDisable = &glDisable_enc;
11089         this->glDisableVertexAttribArray = &glDisableVertexAttribArray_enc;
11090         this->glDrawArrays = &glDrawArrays_enc;
11091         this->glDrawElements = (glDrawElements_client_proc_t) &enc_unsupported;
11092         this->glEnable = &glEnable_enc;
11093         this->glEnableVertexAttribArray = &glEnableVertexAttribArray_enc;
11094         this->glFinish = &glFinish_enc;
11095         this->glFlush = &glFlush_enc;
11096         this->glFramebufferRenderbuffer = &glFramebufferRenderbuffer_enc;
11097         this->glFramebufferTexture2D = &glFramebufferTexture2D_enc;
11098         this->glFrontFace = &glFrontFace_enc;
11099         this->glGenBuffers = &glGenBuffers_enc;
11100         this->glGenerateMipmap = &glGenerateMipmap_enc;
11101         this->glGenFramebuffers = &glGenFramebuffers_enc;
11102         this->glGenRenderbuffers = &glGenRenderbuffers_enc;
11103         this->glGenTextures = &glGenTextures_enc;
11104         this->glGetActiveAttrib = &glGetActiveAttrib_enc;
11105         this->glGetActiveUniform = &glGetActiveUniform_enc;
11106         this->glGetAttachedShaders = &glGetAttachedShaders_enc;
11107         this->glGetAttribLocation = &glGetAttribLocation_enc;
11108         this->glGetBooleanv = &glGetBooleanv_enc;
11109         this->glGetBufferParameteriv = &glGetBufferParameteriv_enc;
11110         this->glGetError = &glGetError_enc;
11111         this->glGetFloatv = &glGetFloatv_enc;
11112         this->glGetFramebufferAttachmentParameteriv = &glGetFramebufferAttachmentParameteriv_enc;
11113         this->glGetIntegerv = &glGetIntegerv_enc;
11114         this->glGetProgramiv = &glGetProgramiv_enc;
11115         this->glGetProgramInfoLog = &glGetProgramInfoLog_enc;
11116         this->glGetRenderbufferParameteriv = &glGetRenderbufferParameteriv_enc;
11117         this->glGetShaderiv = &glGetShaderiv_enc;
11118         this->glGetShaderInfoLog = &glGetShaderInfoLog_enc;
11119         this->glGetShaderPrecisionFormat = &glGetShaderPrecisionFormat_enc;
11120         this->glGetShaderSource = &glGetShaderSource_enc;
11121         this->glGetString = (glGetString_client_proc_t) &enc_unsupported;
11122         this->glGetTexParameterfv = &glGetTexParameterfv_enc;
11123         this->glGetTexParameteriv = &glGetTexParameteriv_enc;
11124         this->glGetUniformfv = &glGetUniformfv_enc;
11125         this->glGetUniformiv = &glGetUniformiv_enc;
11126         this->glGetUniformLocation = &glGetUniformLocation_enc;
11127         this->glGetVertexAttribfv = &glGetVertexAttribfv_enc;
11128         this->glGetVertexAttribiv = &glGetVertexAttribiv_enc;
11129         this->glGetVertexAttribPointerv = (glGetVertexAttribPointerv_client_proc_t) &enc_unsupported;
11130         this->glHint = &glHint_enc;
11131         this->glIsBuffer = &glIsBuffer_enc;
11132         this->glIsEnabled = &glIsEnabled_enc;
11133         this->glIsFramebuffer = &glIsFramebuffer_enc;
11134         this->glIsProgram = &glIsProgram_enc;
11135         this->glIsRenderbuffer = &glIsRenderbuffer_enc;
11136         this->glIsShader = &glIsShader_enc;
11137         this->glIsTexture = &glIsTexture_enc;
11138         this->glLineWidth = &glLineWidth_enc;
11139         this->glLinkProgram = &glLinkProgram_enc;
11140         this->glPixelStorei = &glPixelStorei_enc;
11141         this->glPolygonOffset = &glPolygonOffset_enc;
11142         this->glReadPixels = &glReadPixels_enc;
11143         this->glReleaseShaderCompiler = &glReleaseShaderCompiler_enc;
11144         this->glRenderbufferStorage = &glRenderbufferStorage_enc;
11145         this->glSampleCoverage = &glSampleCoverage_enc;
11146         this->glScissor = &glScissor_enc;
11147         this->glShaderBinary = (glShaderBinary_client_proc_t) &enc_unsupported;
11148         this->glShaderSource = (glShaderSource_client_proc_t) &enc_unsupported;
11149         this->glStencilFunc = &glStencilFunc_enc;
11150         this->glStencilFuncSeparate = &glStencilFuncSeparate_enc;
11151         this->glStencilMask = &glStencilMask_enc;
11152         this->glStencilMaskSeparate = &glStencilMaskSeparate_enc;
11153         this->glStencilOp = &glStencilOp_enc;
11154         this->glStencilOpSeparate = &glStencilOpSeparate_enc;
11155         this->glTexImage2D = &glTexImage2D_enc;
11156         this->glTexParameterf = &glTexParameterf_enc;
11157         this->glTexParameterfv = &glTexParameterfv_enc;
11158         this->glTexParameteri = &glTexParameteri_enc;
11159         this->glTexParameteriv = &glTexParameteriv_enc;
11160         this->glTexSubImage2D = &glTexSubImage2D_enc;
11161         this->glUniform1f = &glUniform1f_enc;
11162         this->glUniform1fv = &glUniform1fv_enc;
11163         this->glUniform1i = &glUniform1i_enc;
11164         this->glUniform1iv = &glUniform1iv_enc;
11165         this->glUniform2f = &glUniform2f_enc;
11166         this->glUniform2fv = &glUniform2fv_enc;
11167         this->glUniform2i = &glUniform2i_enc;
11168         this->glUniform2iv = &glUniform2iv_enc;
11169         this->glUniform3f = &glUniform3f_enc;
11170         this->glUniform3fv = &glUniform3fv_enc;
11171         this->glUniform3i = &glUniform3i_enc;
11172         this->glUniform3iv = &glUniform3iv_enc;
11173         this->glUniform4f = &glUniform4f_enc;
11174         this->glUniform4fv = &glUniform4fv_enc;
11175         this->glUniform4i = &glUniform4i_enc;
11176         this->glUniform4iv = &glUniform4iv_enc;
11177         this->glUniformMatrix2fv = &glUniformMatrix2fv_enc;
11178         this->glUniformMatrix3fv = &glUniformMatrix3fv_enc;
11179         this->glUniformMatrix4fv = &glUniformMatrix4fv_enc;
11180         this->glUseProgram = &glUseProgram_enc;
11181         this->glValidateProgram = &glValidateProgram_enc;
11182         this->glVertexAttrib1f = &glVertexAttrib1f_enc;
11183         this->glVertexAttrib1fv = &glVertexAttrib1fv_enc;
11184         this->glVertexAttrib2f = &glVertexAttrib2f_enc;
11185         this->glVertexAttrib2fv = &glVertexAttrib2fv_enc;
11186         this->glVertexAttrib3f = &glVertexAttrib3f_enc;
11187         this->glVertexAttrib3fv = &glVertexAttrib3fv_enc;
11188         this->glVertexAttrib4f = &glVertexAttrib4f_enc;
11189         this->glVertexAttrib4fv = &glVertexAttrib4fv_enc;
11190         this->glVertexAttribPointer = (glVertexAttribPointer_client_proc_t) &enc_unsupported;
11191         this->glViewport = &glViewport_enc;
11192         this->glEGLImageTargetTexture2DOES = &glEGLImageTargetTexture2DOES_enc;
11193         this->glEGLImageTargetRenderbufferStorageOES = &glEGLImageTargetRenderbufferStorageOES_enc;
11194         this->glGetProgramBinaryOES = (glGetProgramBinaryOES_client_proc_t) &enc_unsupported;
11195         this->glProgramBinaryOES = (glProgramBinaryOES_client_proc_t) &enc_unsupported;
11196         this->glMapBufferOES = (glMapBufferOES_client_proc_t) &enc_unsupported;
11197         this->glUnmapBufferOES = &glUnmapBufferOES_enc;
11198         this->glTexImage3DOES = &glTexImage3DOES_enc;
11199         this->glTexSubImage3DOES = &glTexSubImage3DOES_enc;
11200         this->glCopyTexSubImage3DOES = &glCopyTexSubImage3DOES_enc;
11201         this->glCompressedTexImage3DOES = &glCompressedTexImage3DOES_enc;
11202         this->glCompressedTexSubImage3DOES = &glCompressedTexSubImage3DOES_enc;
11203         this->glFramebufferTexture3DOES = &glFramebufferTexture3DOES_enc;
11204         this->glBindVertexArrayOES = &glBindVertexArrayOES_enc;
11205         this->glDeleteVertexArraysOES = &glDeleteVertexArraysOES_enc;
11206         this->glGenVertexArraysOES = &glGenVertexArraysOES_enc;
11207         this->glIsVertexArrayOES = &glIsVertexArrayOES_enc;
11208         this->glDiscardFramebufferEXT = &glDiscardFramebufferEXT_enc;
11209         this->glMultiDrawArraysEXT = (glMultiDrawArraysEXT_client_proc_t) &enc_unsupported;
11210         this->glMultiDrawElementsEXT = (glMultiDrawElementsEXT_client_proc_t) &enc_unsupported;
11211         this->glGetPerfMonitorGroupsAMD = (glGetPerfMonitorGroupsAMD_client_proc_t) &enc_unsupported;
11212         this->glGetPerfMonitorCountersAMD = (glGetPerfMonitorCountersAMD_client_proc_t) &enc_unsupported;
11213         this->glGetPerfMonitorGroupStringAMD = (glGetPerfMonitorGroupStringAMD_client_proc_t) &enc_unsupported;
11214         this->glGetPerfMonitorCounterStringAMD = (glGetPerfMonitorCounterStringAMD_client_proc_t) &enc_unsupported;
11215         this->glGetPerfMonitorCounterInfoAMD = (glGetPerfMonitorCounterInfoAMD_client_proc_t) &enc_unsupported;
11216         this->glGenPerfMonitorsAMD = (glGenPerfMonitorsAMD_client_proc_t) &enc_unsupported;
11217         this->glDeletePerfMonitorsAMD = (glDeletePerfMonitorsAMD_client_proc_t) &enc_unsupported;
11218         this->glSelectPerfMonitorCountersAMD = (glSelectPerfMonitorCountersAMD_client_proc_t) &enc_unsupported;
11219         this->glBeginPerfMonitorAMD = (glBeginPerfMonitorAMD_client_proc_t) &enc_unsupported;
11220         this->glEndPerfMonitorAMD = (glEndPerfMonitorAMD_client_proc_t) &enc_unsupported;
11221         this->glGetPerfMonitorCounterDataAMD = (glGetPerfMonitorCounterDataAMD_client_proc_t) &enc_unsupported;
11222         this->glRenderbufferStorageMultisampleIMG = (glRenderbufferStorageMultisampleIMG_client_proc_t) &enc_unsupported;
11223         this->glFramebufferTexture2DMultisampleIMG = (glFramebufferTexture2DMultisampleIMG_client_proc_t) &enc_unsupported;
11224         this->glDeleteFencesNV = (glDeleteFencesNV_client_proc_t) &enc_unsupported;
11225         this->glGenFencesNV = (glGenFencesNV_client_proc_t) &enc_unsupported;
11226         this->glIsFenceNV = (glIsFenceNV_client_proc_t) &enc_unsupported;
11227         this->glTestFenceNV = (glTestFenceNV_client_proc_t) &enc_unsupported;
11228         this->glGetFenceivNV = (glGetFenceivNV_client_proc_t) &enc_unsupported;
11229         this->glFinishFenceNV = (glFinishFenceNV_client_proc_t) &enc_unsupported;
11230         this->glSetFenceNV = (glSetFenceNV_client_proc_t) &enc_unsupported;
11231         this->glCoverageMaskNV = (glCoverageMaskNV_client_proc_t) &enc_unsupported;
11232         this->glCoverageOperationNV = (glCoverageOperationNV_client_proc_t) &enc_unsupported;
11233         this->glGetDriverControlsQCOM = (glGetDriverControlsQCOM_client_proc_t) &enc_unsupported;
11234         this->glGetDriverControlStringQCOM = (glGetDriverControlStringQCOM_client_proc_t) &enc_unsupported;
11235         this->glEnableDriverControlQCOM = (glEnableDriverControlQCOM_client_proc_t) &enc_unsupported;
11236         this->glDisableDriverControlQCOM = (glDisableDriverControlQCOM_client_proc_t) &enc_unsupported;
11237         this->glExtGetTexturesQCOM = (glExtGetTexturesQCOM_client_proc_t) &enc_unsupported;
11238         this->glExtGetBuffersQCOM = (glExtGetBuffersQCOM_client_proc_t) &enc_unsupported;
11239         this->glExtGetRenderbuffersQCOM = (glExtGetRenderbuffersQCOM_client_proc_t) &enc_unsupported;
11240         this->glExtGetFramebuffersQCOM = (glExtGetFramebuffersQCOM_client_proc_t) &enc_unsupported;
11241         this->glExtGetTexLevelParameterivQCOM = (glExtGetTexLevelParameterivQCOM_client_proc_t) &enc_unsupported;
11242         this->glExtTexObjectStateOverrideiQCOM = (glExtTexObjectStateOverrideiQCOM_client_proc_t) &enc_unsupported;
11243         this->glExtGetTexSubImageQCOM = (glExtGetTexSubImageQCOM_client_proc_t) &enc_unsupported;
11244         this->glExtGetBufferPointervQCOM = (glExtGetBufferPointervQCOM_client_proc_t) &enc_unsupported;
11245         this->glExtGetShadersQCOM = (glExtGetShadersQCOM_client_proc_t) &enc_unsupported;
11246         this->glExtGetProgramsQCOM = (glExtGetProgramsQCOM_client_proc_t) &enc_unsupported;
11247         this->glExtIsProgramBinaryQCOM = (glExtIsProgramBinaryQCOM_client_proc_t) &enc_unsupported;
11248         this->glExtGetProgramBinarySourceQCOM = (glExtGetProgramBinarySourceQCOM_client_proc_t) &enc_unsupported;
11249         this->glStartTilingQCOM = (glStartTilingQCOM_client_proc_t) &enc_unsupported;
11250         this->glEndTilingQCOM = (glEndTilingQCOM_client_proc_t) &enc_unsupported;
11251         this->glVertexAttribPointerData = &glVertexAttribPointerData_enc;
11252         this->glVertexAttribPointerOffset = &glVertexAttribPointerOffset_enc;
11253         this->glDrawElementsOffset = &glDrawElementsOffset_enc;
11254         this->glDrawElementsData = &glDrawElementsData_enc;
11255         this->glGetCompressedTextureFormats = &glGetCompressedTextureFormats_enc;
11256         this->glShaderString = &glShaderString_enc;
11257         this->glFinishRoundTrip = &glFinishRoundTrip_enc;
11258         this->glGenVertexArrays = &glGenVertexArrays_enc;
11259         this->glBindVertexArray = &glBindVertexArray_enc;
11260         this->glDeleteVertexArrays = &glDeleteVertexArrays_enc;
11261         this->glIsVertexArray = &glIsVertexArray_enc;
11262         this->glMapBufferRange = (glMapBufferRange_client_proc_t) &enc_unsupported;
11263         this->glUnmapBuffer = (glUnmapBuffer_client_proc_t) &enc_unsupported;
11264         this->glFlushMappedBufferRange = (glFlushMappedBufferRange_client_proc_t) &enc_unsupported;
11265         this->glMapBufferRangeAEMU = &glMapBufferRangeAEMU_enc;
11266         this->glUnmapBufferAEMU = &glUnmapBufferAEMU_enc;
11267         this->glFlushMappedBufferRangeAEMU = &glFlushMappedBufferRangeAEMU_enc;
11268         this->glReadPixelsOffsetAEMU = &glReadPixelsOffsetAEMU_enc;
11269         this->glCompressedTexImage2DOffsetAEMU = &glCompressedTexImage2DOffsetAEMU_enc;
11270         this->glCompressedTexSubImage2DOffsetAEMU = &glCompressedTexSubImage2DOffsetAEMU_enc;
11271         this->glTexImage2DOffsetAEMU = &glTexImage2DOffsetAEMU_enc;
11272         this->glTexSubImage2DOffsetAEMU = &glTexSubImage2DOffsetAEMU_enc;
11273         this->glBindBufferRange = &glBindBufferRange_enc;
11274         this->glBindBufferBase = &glBindBufferBase_enc;
11275         this->glCopyBufferSubData = &glCopyBufferSubData_enc;
11276         this->glClearBufferiv = &glClearBufferiv_enc;
11277         this->glClearBufferuiv = &glClearBufferuiv_enc;
11278         this->glClearBufferfv = &glClearBufferfv_enc;
11279         this->glClearBufferfi = &glClearBufferfi_enc;
11280         this->glGetBufferParameteri64v = (glGetBufferParameteri64v_client_proc_t) &enc_unsupported;
11281         this->glGetBufferPointerv = (glGetBufferPointerv_client_proc_t) &enc_unsupported;
11282         this->glUniformBlockBinding = &glUniformBlockBinding_enc;
11283         this->glGetUniformBlockIndex = &glGetUniformBlockIndex_enc;
11284         this->glGetUniformIndices = (glGetUniformIndices_client_proc_t) &enc_unsupported;
11285         this->glGetUniformIndicesAEMU = &glGetUniformIndicesAEMU_enc;
11286         this->glGetActiveUniformBlockiv = &glGetActiveUniformBlockiv_enc;
11287         this->glGetActiveUniformBlockName = &glGetActiveUniformBlockName_enc;
11288         this->glUniform1ui = &glUniform1ui_enc;
11289         this->glUniform2ui = &glUniform2ui_enc;
11290         this->glUniform3ui = &glUniform3ui_enc;
11291         this->glUniform4ui = &glUniform4ui_enc;
11292         this->glUniform1uiv = &glUniform1uiv_enc;
11293         this->glUniform2uiv = &glUniform2uiv_enc;
11294         this->glUniform3uiv = &glUniform3uiv_enc;
11295         this->glUniform4uiv = &glUniform4uiv_enc;
11296         this->glUniformMatrix2x3fv = &glUniformMatrix2x3fv_enc;
11297         this->glUniformMatrix3x2fv = &glUniformMatrix3x2fv_enc;
11298         this->glUniformMatrix2x4fv = &glUniformMatrix2x4fv_enc;
11299         this->glUniformMatrix4x2fv = &glUniformMatrix4x2fv_enc;
11300         this->glUniformMatrix3x4fv = &glUniformMatrix3x4fv_enc;
11301         this->glUniformMatrix4x3fv = &glUniformMatrix4x3fv_enc;
11302         this->glGetUniformuiv = &glGetUniformuiv_enc;
11303         this->glGetActiveUniformsiv = &glGetActiveUniformsiv_enc;
11304         this->glVertexAttribI4i = &glVertexAttribI4i_enc;
11305         this->glVertexAttribI4ui = &glVertexAttribI4ui_enc;
11306         this->glVertexAttribI4iv = &glVertexAttribI4iv_enc;
11307         this->glVertexAttribI4uiv = &glVertexAttribI4uiv_enc;
11308         this->glVertexAttribIPointer = (glVertexAttribIPointer_client_proc_t) &enc_unsupported;
11309         this->glVertexAttribIPointerOffsetAEMU = &glVertexAttribIPointerOffsetAEMU_enc;
11310         this->glVertexAttribIPointerDataAEMU = &glVertexAttribIPointerDataAEMU_enc;
11311         this->glGetVertexAttribIiv = &glGetVertexAttribIiv_enc;
11312         this->glGetVertexAttribIuiv = &glGetVertexAttribIuiv_enc;
11313         this->glVertexAttribDivisor = &glVertexAttribDivisor_enc;
11314         this->glDrawArraysInstanced = &glDrawArraysInstanced_enc;
11315         this->glDrawElementsInstanced = (glDrawElementsInstanced_client_proc_t) &enc_unsupported;
11316         this->glDrawElementsInstancedDataAEMU = &glDrawElementsInstancedDataAEMU_enc;
11317         this->glDrawElementsInstancedOffsetAEMU = &glDrawElementsInstancedOffsetAEMU_enc;
11318         this->glDrawRangeElements = (glDrawRangeElements_client_proc_t) &enc_unsupported;
11319         this->glDrawRangeElementsDataAEMU = &glDrawRangeElementsDataAEMU_enc;
11320         this->glDrawRangeElementsOffsetAEMU = &glDrawRangeElementsOffsetAEMU_enc;
11321         this->glFenceSync = (glFenceSync_client_proc_t) &enc_unsupported;
11322         this->glClientWaitSync = (glClientWaitSync_client_proc_t) &enc_unsupported;
11323         this->glWaitSync = (glWaitSync_client_proc_t) &enc_unsupported;
11324         this->glDeleteSync = (glDeleteSync_client_proc_t) &enc_unsupported;
11325         this->glIsSync = (glIsSync_client_proc_t) &enc_unsupported;
11326         this->glGetSynciv = (glGetSynciv_client_proc_t) &enc_unsupported;
11327         this->glFenceSyncAEMU = &glFenceSyncAEMU_enc;
11328         this->glClientWaitSyncAEMU = &glClientWaitSyncAEMU_enc;
11329         this->glWaitSyncAEMU = &glWaitSyncAEMU_enc;
11330         this->glDeleteSyncAEMU = &glDeleteSyncAEMU_enc;
11331         this->glIsSyncAEMU = &glIsSyncAEMU_enc;
11332         this->glGetSyncivAEMU = &glGetSyncivAEMU_enc;
11333         this->glDrawBuffers = &glDrawBuffers_enc;
11334         this->glReadBuffer = &glReadBuffer_enc;
11335         this->glBlitFramebuffer = &glBlitFramebuffer_enc;
11336         this->glInvalidateFramebuffer = &glInvalidateFramebuffer_enc;
11337         this->glInvalidateSubFramebuffer = &glInvalidateSubFramebuffer_enc;
11338         this->glFramebufferTextureLayer = &glFramebufferTextureLayer_enc;
11339         this->glRenderbufferStorageMultisample = &glRenderbufferStorageMultisample_enc;
11340         this->glTexStorage2D = &glTexStorage2D_enc;
11341         this->glGetInternalformativ = &glGetInternalformativ_enc;
11342         this->glBeginTransformFeedback = &glBeginTransformFeedback_enc;
11343         this->glEndTransformFeedback = &glEndTransformFeedback_enc;
11344         this->glGenTransformFeedbacks = &glGenTransformFeedbacks_enc;
11345         this->glDeleteTransformFeedbacks = &glDeleteTransformFeedbacks_enc;
11346         this->glBindTransformFeedback = &glBindTransformFeedback_enc;
11347         this->glPauseTransformFeedback = &glPauseTransformFeedback_enc;
11348         this->glResumeTransformFeedback = &glResumeTransformFeedback_enc;
11349         this->glIsTransformFeedback = &glIsTransformFeedback_enc;
11350         this->glTransformFeedbackVaryings = (glTransformFeedbackVaryings_client_proc_t) &enc_unsupported;
11351         this->glTransformFeedbackVaryingsAEMU = &glTransformFeedbackVaryingsAEMU_enc;
11352         this->glGetTransformFeedbackVarying = &glGetTransformFeedbackVarying_enc;
11353         this->glGenSamplers = &glGenSamplers_enc;
11354         this->glDeleteSamplers = &glDeleteSamplers_enc;
11355         this->glBindSampler = &glBindSampler_enc;
11356         this->glSamplerParameterf = &glSamplerParameterf_enc;
11357         this->glSamplerParameteri = &glSamplerParameteri_enc;
11358         this->glSamplerParameterfv = &glSamplerParameterfv_enc;
11359         this->glSamplerParameteriv = &glSamplerParameteriv_enc;
11360         this->glGetSamplerParameterfv = &glGetSamplerParameterfv_enc;
11361         this->glGetSamplerParameteriv = &glGetSamplerParameteriv_enc;
11362         this->glIsSampler = &glIsSampler_enc;
11363         this->glGenQueries = &glGenQueries_enc;
11364         this->glDeleteQueries = &glDeleteQueries_enc;
11365         this->glBeginQuery = &glBeginQuery_enc;
11366         this->glEndQuery = &glEndQuery_enc;
11367         this->glGetQueryiv = &glGetQueryiv_enc;
11368         this->glGetQueryObjectuiv = &glGetQueryObjectuiv_enc;
11369         this->glIsQuery = &glIsQuery_enc;
11370         this->glProgramParameteri = &glProgramParameteri_enc;
11371         this->glProgramBinary = &glProgramBinary_enc;
11372         this->glGetProgramBinary = &glGetProgramBinary_enc;
11373         this->glGetFragDataLocation = &glGetFragDataLocation_enc;
11374         this->glGetInteger64v = &glGetInteger64v_enc;
11375         this->glGetIntegeri_v = &glGetIntegeri_v_enc;
11376         this->glGetInteger64i_v = &glGetInteger64i_v_enc;
11377         this->glTexImage3D = &glTexImage3D_enc;
11378         this->glTexImage3DOffsetAEMU = &glTexImage3DOffsetAEMU_enc;
11379         this->glTexStorage3D = &glTexStorage3D_enc;
11380         this->glTexSubImage3D = &glTexSubImage3D_enc;
11381         this->glTexSubImage3DOffsetAEMU = &glTexSubImage3DOffsetAEMU_enc;
11382         this->glCompressedTexImage3D = &glCompressedTexImage3D_enc;
11383         this->glCompressedTexImage3DOffsetAEMU = &glCompressedTexImage3DOffsetAEMU_enc;
11384         this->glCompressedTexSubImage3D = &glCompressedTexSubImage3D_enc;
11385         this->glCompressedTexSubImage3DOffsetAEMU = &glCompressedTexSubImage3DOffsetAEMU_enc;
11386         this->glCopyTexSubImage3D = &glCopyTexSubImage3D_enc;
11387         this->glGetStringi = (glGetStringi_client_proc_t) &enc_unsupported;
11388         this->glGetBooleani_v = &glGetBooleani_v_enc;
11389         this->glMemoryBarrier = &glMemoryBarrier_enc;
11390         this->glMemoryBarrierByRegion = &glMemoryBarrierByRegion_enc;
11391         this->glGenProgramPipelines = &glGenProgramPipelines_enc;
11392         this->glDeleteProgramPipelines = &glDeleteProgramPipelines_enc;
11393         this->glBindProgramPipeline = &glBindProgramPipeline_enc;
11394         this->glGetProgramPipelineiv = &glGetProgramPipelineiv_enc;
11395         this->glGetProgramPipelineInfoLog = &glGetProgramPipelineInfoLog_enc;
11396         this->glValidateProgramPipeline = &glValidateProgramPipeline_enc;
11397         this->glIsProgramPipeline = &glIsProgramPipeline_enc;
11398         this->glUseProgramStages = &glUseProgramStages_enc;
11399         this->glActiveShaderProgram = &glActiveShaderProgram_enc;
11400         this->glCreateShaderProgramv = (glCreateShaderProgramv_client_proc_t) &enc_unsupported;
11401         this->glCreateShaderProgramvAEMU = &glCreateShaderProgramvAEMU_enc;
11402         this->glProgramUniform1f = &glProgramUniform1f_enc;
11403         this->glProgramUniform2f = &glProgramUniform2f_enc;
11404         this->glProgramUniform3f = &glProgramUniform3f_enc;
11405         this->glProgramUniform4f = &glProgramUniform4f_enc;
11406         this->glProgramUniform1i = &glProgramUniform1i_enc;
11407         this->glProgramUniform2i = &glProgramUniform2i_enc;
11408         this->glProgramUniform3i = &glProgramUniform3i_enc;
11409         this->glProgramUniform4i = &glProgramUniform4i_enc;
11410         this->glProgramUniform1ui = &glProgramUniform1ui_enc;
11411         this->glProgramUniform2ui = &glProgramUniform2ui_enc;
11412         this->glProgramUniform3ui = &glProgramUniform3ui_enc;
11413         this->glProgramUniform4ui = &glProgramUniform4ui_enc;
11414         this->glProgramUniform1fv = &glProgramUniform1fv_enc;
11415         this->glProgramUniform2fv = &glProgramUniform2fv_enc;
11416         this->glProgramUniform3fv = &glProgramUniform3fv_enc;
11417         this->glProgramUniform4fv = &glProgramUniform4fv_enc;
11418         this->glProgramUniform1iv = &glProgramUniform1iv_enc;
11419         this->glProgramUniform2iv = &glProgramUniform2iv_enc;
11420         this->glProgramUniform3iv = &glProgramUniform3iv_enc;
11421         this->glProgramUniform4iv = &glProgramUniform4iv_enc;
11422         this->glProgramUniform1uiv = &glProgramUniform1uiv_enc;
11423         this->glProgramUniform2uiv = &glProgramUniform2uiv_enc;
11424         this->glProgramUniform3uiv = &glProgramUniform3uiv_enc;
11425         this->glProgramUniform4uiv = &glProgramUniform4uiv_enc;
11426         this->glProgramUniformMatrix2fv = &glProgramUniformMatrix2fv_enc;
11427         this->glProgramUniformMatrix3fv = &glProgramUniformMatrix3fv_enc;
11428         this->glProgramUniformMatrix4fv = &glProgramUniformMatrix4fv_enc;
11429         this->glProgramUniformMatrix2x3fv = &glProgramUniformMatrix2x3fv_enc;
11430         this->glProgramUniformMatrix3x2fv = &glProgramUniformMatrix3x2fv_enc;
11431         this->glProgramUniformMatrix2x4fv = &glProgramUniformMatrix2x4fv_enc;
11432         this->glProgramUniformMatrix4x2fv = &glProgramUniformMatrix4x2fv_enc;
11433         this->glProgramUniformMatrix3x4fv = &glProgramUniformMatrix3x4fv_enc;
11434         this->glProgramUniformMatrix4x3fv = &glProgramUniformMatrix4x3fv_enc;
11435         this->glGetProgramInterfaceiv = &glGetProgramInterfaceiv_enc;
11436         this->glGetProgramResourceiv = &glGetProgramResourceiv_enc;
11437         this->glGetProgramResourceIndex = &glGetProgramResourceIndex_enc;
11438         this->glGetProgramResourceLocation = &glGetProgramResourceLocation_enc;
11439         this->glGetProgramResourceName = &glGetProgramResourceName_enc;
11440         this->glBindImageTexture = &glBindImageTexture_enc;
11441         this->glDispatchCompute = &glDispatchCompute_enc;
11442         this->glDispatchComputeIndirect = &glDispatchComputeIndirect_enc;
11443         this->glBindVertexBuffer = &glBindVertexBuffer_enc;
11444         this->glVertexAttribBinding = &glVertexAttribBinding_enc;
11445         this->glVertexAttribFormat = &glVertexAttribFormat_enc;
11446         this->glVertexAttribIFormat = &glVertexAttribIFormat_enc;
11447         this->glVertexBindingDivisor = &glVertexBindingDivisor_enc;
11448         this->glDrawArraysIndirect = (glDrawArraysIndirect_client_proc_t) &enc_unsupported;
11449         this->glDrawArraysIndirectDataAEMU = &glDrawArraysIndirectDataAEMU_enc;
11450         this->glDrawArraysIndirectOffsetAEMU = &glDrawArraysIndirectOffsetAEMU_enc;
11451         this->glDrawElementsIndirect = (glDrawElementsIndirect_client_proc_t) &enc_unsupported;
11452         this->glDrawElementsIndirectDataAEMU = &glDrawElementsIndirectDataAEMU_enc;
11453         this->glDrawElementsIndirectOffsetAEMU = &glDrawElementsIndirectOffsetAEMU_enc;
11454         this->glTexStorage2DMultisample = &glTexStorage2DMultisample_enc;
11455         this->glSampleMaski = &glSampleMaski_enc;
11456         this->glGetMultisamplefv = &glGetMultisamplefv_enc;
11457         this->glFramebufferParameteri = &glFramebufferParameteri_enc;
11458         this->glGetFramebufferParameteriv = &glGetFramebufferParameteriv_enc;
11459         this->glGetTexLevelParameterfv = &glGetTexLevelParameterfv_enc;
11460         this->glGetTexLevelParameteriv = &glGetTexLevelParameteriv_enc;
11461 }
11462