src/type3_AndroidCloud/anbox-master/android/opengl/system/GLESv1_enc/gl_enc.cpp

   1 // Generated Code - DO NOT EDIT !!
   2 // generated by 'emugen'
   3
   4
   5 #include <memory>
   6 #include <string.h>
   7 #include "gl_opcodes.h"
   8
   9 #include "gl_enc.h"
  10
  11
  12 #include <stdio.h>
  13
  14 namespace {
  15
  16 void enc_unsupported()
  17 {
  18         ALOGE("Function is unsupported\n");
  19 }
  20
  21 void glAlphaFunc_enc(void *self , GLenum func, GLclampf ref)
  22 {
  23
  24         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
  25         IOStream *stream = ctx->m_stream;
  26         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
  27         bool useChecksum = checksumCalculator->getVersion() > 0;
  28
  29          unsigned char *ptr;
  30          unsigned char *buf;
  31          const size_t sizeWithoutChecksum = 8 + 4 + 4;
  32          const size_t checksumSize = checksumCalculator->checksumByteSize();
  33          const size_t totalSize = sizeWithoutChecksum + checksumSize;
  34         buf = stream->alloc(totalSize);
  35         ptr = buf;
  36         int tmp = OP_glAlphaFunc;memcpy(ptr, &tmp, 4); ptr += 4;
  37         memcpy(ptr, &totalSize, 4);  ptr += 4;
  38
  39                 memcpy(ptr, &func, 4); ptr += 4;
  40                 memcpy(ptr, &ref, 4); ptr += 4;
  41
  42         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
  43         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
  44
  45 }
  46
  47 void glClearColor_enc(void *self , GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
  48 {
  49
  50         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
  51         IOStream *stream = ctx->m_stream;
  52         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
  53         bool useChecksum = checksumCalculator->getVersion() > 0;
  54
  55          unsigned char *ptr;
  56          unsigned char *buf;
  57          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
  58          const size_t checksumSize = checksumCalculator->checksumByteSize();
  59          const size_t totalSize = sizeWithoutChecksum + checksumSize;
  60         buf = stream->alloc(totalSize);
  61         ptr = buf;
  62         int tmp = OP_glClearColor;memcpy(ptr, &tmp, 4); ptr += 4;
  63         memcpy(ptr, &totalSize, 4);  ptr += 4;
  64
  65                 memcpy(ptr, &red, 4); ptr += 4;
  66                 memcpy(ptr, &green, 4); ptr += 4;
  67                 memcpy(ptr, &blue, 4); ptr += 4;
  68                 memcpy(ptr, &alpha, 4); ptr += 4;
  69
  70         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
  71         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
  72
  73 }
  74
  75 void glClearDepthf_enc(void *self , GLclampf depth)
  76 {
  77
  78         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
  79         IOStream *stream = ctx->m_stream;
  80         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
  81         bool useChecksum = checksumCalculator->getVersion() > 0;
  82
  83          unsigned char *ptr;
  84          unsigned char *buf;
  85          const size_t sizeWithoutChecksum = 8 + 4;
  86          const size_t checksumSize = checksumCalculator->checksumByteSize();
  87          const size_t totalSize = sizeWithoutChecksum + checksumSize;
  88         buf = stream->alloc(totalSize);
  89         ptr = buf;
  90         int tmp = OP_glClearDepthf;memcpy(ptr, &tmp, 4); ptr += 4;
  91         memcpy(ptr, &totalSize, 4);  ptr += 4;
  92
  93                 memcpy(ptr, &depth, 4); ptr += 4;
  94
  95         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
  96         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
  97
  98 }
  99
 100 void glClipPlanef_enc(void *self , GLenum plane, const GLfloat* equation)
 101 {
 102
 103         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 104         IOStream *stream = ctx->m_stream;
 105         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 106         bool useChecksum = checksumCalculator->getVersion() > 0;
 107
 108         const unsigned int __size_equation =  (4 * sizeof(float));
 109          unsigned char *ptr;
 110          unsigned char *buf;
 111          const size_t sizeWithoutChecksum = 8 + 4 + __size_equation + 1*4;
 112          const size_t checksumSize = checksumCalculator->checksumByteSize();
 113          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 114         buf = stream->alloc(totalSize);
 115         ptr = buf;
 116         int tmp = OP_glClipPlanef;memcpy(ptr, &tmp, 4); ptr += 4;
 117         memcpy(ptr, &totalSize, 4);  ptr += 4;
 118
 119                 memcpy(ptr, &plane, 4); ptr += 4;
 120         *(unsigned int *)(ptr) = __size_equation; ptr += 4;
 121         memcpy(ptr, equation, __size_equation);ptr += __size_equation;
 122
 123         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 124         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 125
 126 }
 127
 128 void glColor4f_enc(void *self , GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 129 {
 130
 131         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 132         IOStream *stream = ctx->m_stream;
 133         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 134         bool useChecksum = checksumCalculator->getVersion() > 0;
 135
 136          unsigned char *ptr;
 137          unsigned char *buf;
 138          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
 139          const size_t checksumSize = checksumCalculator->checksumByteSize();
 140          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 141         buf = stream->alloc(totalSize);
 142         ptr = buf;
 143         int tmp = OP_glColor4f;memcpy(ptr, &tmp, 4); ptr += 4;
 144         memcpy(ptr, &totalSize, 4);  ptr += 4;
 145
 146                 memcpy(ptr, &red, 4); ptr += 4;
 147                 memcpy(ptr, &green, 4); ptr += 4;
 148                 memcpy(ptr, &blue, 4); ptr += 4;
 149                 memcpy(ptr, &alpha, 4); ptr += 4;
 150
 151         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 152         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 153
 154 }
 155
 156 void glDepthRangef_enc(void *self , GLclampf zNear, GLclampf zFar)
 157 {
 158
 159         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 160         IOStream *stream = ctx->m_stream;
 161         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 162         bool useChecksum = checksumCalculator->getVersion() > 0;
 163
 164          unsigned char *ptr;
 165          unsigned char *buf;
 166          const size_t sizeWithoutChecksum = 8 + 4 + 4;
 167          const size_t checksumSize = checksumCalculator->checksumByteSize();
 168          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 169         buf = stream->alloc(totalSize);
 170         ptr = buf;
 171         int tmp = OP_glDepthRangef;memcpy(ptr, &tmp, 4); ptr += 4;
 172         memcpy(ptr, &totalSize, 4);  ptr += 4;
 173
 174                 memcpy(ptr, &zNear, 4); ptr += 4;
 175                 memcpy(ptr, &zFar, 4); ptr += 4;
 176
 177         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 178         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 179
 180 }
 181
 182 void glFogf_enc(void *self , GLenum pname, GLfloat param)
 183 {
 184
 185         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 186         IOStream *stream = ctx->m_stream;
 187         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 188         bool useChecksum = checksumCalculator->getVersion() > 0;
 189
 190          unsigned char *ptr;
 191          unsigned char *buf;
 192          const size_t sizeWithoutChecksum = 8 + 4 + 4;
 193          const size_t checksumSize = checksumCalculator->checksumByteSize();
 194          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 195         buf = stream->alloc(totalSize);
 196         ptr = buf;
 197         int tmp = OP_glFogf;memcpy(ptr, &tmp, 4); ptr += 4;
 198         memcpy(ptr, &totalSize, 4);  ptr += 4;
 199
 200                 memcpy(ptr, &pname, 4); ptr += 4;
 201                 memcpy(ptr, &param, 4); ptr += 4;
 202
 203         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 204         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 205
 206 }
 207
 208 void glFogfv_enc(void *self , GLenum pname, const GLfloat* params)
 209 {
 210
 211         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 212         IOStream *stream = ctx->m_stream;
 213         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 214         bool useChecksum = checksumCalculator->getVersion() > 0;
 215
 216         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
 217          unsigned char *ptr;
 218          unsigned char *buf;
 219          const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4;
 220          const size_t checksumSize = checksumCalculator->checksumByteSize();
 221          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 222         buf = stream->alloc(totalSize);
 223         ptr = buf;
 224         int tmp = OP_glFogfv;memcpy(ptr, &tmp, 4); ptr += 4;
 225         memcpy(ptr, &totalSize, 4);  ptr += 4;
 226
 227                 memcpy(ptr, &pname, 4); ptr += 4;
 228         *(unsigned int *)(ptr) = __size_params; ptr += 4;
 229         memcpy(ptr, params, __size_params);ptr += __size_params;
 230
 231         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 232         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 233
 234 }
 235
 236 void glFrustumf_enc(void *self , GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 237 {
 238
 239         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 240         IOStream *stream = ctx->m_stream;
 241         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 242         bool useChecksum = checksumCalculator->getVersion() > 0;
 243
 244          unsigned char *ptr;
 245          unsigned char *buf;
 246          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4;
 247          const size_t checksumSize = checksumCalculator->checksumByteSize();
 248          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 249         buf = stream->alloc(totalSize);
 250         ptr = buf;
 251         int tmp = OP_glFrustumf;memcpy(ptr, &tmp, 4); ptr += 4;
 252         memcpy(ptr, &totalSize, 4);  ptr += 4;
 253
 254                 memcpy(ptr, &left, 4); ptr += 4;
 255                 memcpy(ptr, &right, 4); ptr += 4;
 256                 memcpy(ptr, &bottom, 4); ptr += 4;
 257                 memcpy(ptr, &top, 4); ptr += 4;
 258                 memcpy(ptr, &zNear, 4); ptr += 4;
 259                 memcpy(ptr, &zFar, 4); ptr += 4;
 260
 261         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 262         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 263
 264 }
 265
 266 void glGetClipPlanef_enc(void *self , GLenum pname, GLfloat* eqn)
 267 {
 268
 269         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 270         IOStream *stream = ctx->m_stream;
 271         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 272         bool useChecksum = checksumCalculator->getVersion() > 0;
 273
 274         const unsigned int __size_eqn =  (4 * sizeof(GLfloat));
 275          unsigned char *ptr;
 276          unsigned char *buf;
 277          const size_t sizeWithoutChecksum = 8 + 4 + __size_eqn + 1*4;
 278          const size_t checksumSize = checksumCalculator->checksumByteSize();
 279          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 280         buf = stream->alloc(totalSize);
 281         ptr = buf;
 282         int tmp = OP_glGetClipPlanef;memcpy(ptr, &tmp, 4); ptr += 4;
 283         memcpy(ptr, &totalSize, 4);  ptr += 4;
 284
 285                 memcpy(ptr, &pname, 4); ptr += 4;
 286         *(unsigned int *)(ptr) = __size_eqn; ptr += 4;
 287
 288         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 289         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 290
 291         stream->readback(eqn, __size_eqn);
 292         if (useChecksum) checksumCalculator->addBuffer(eqn, __size_eqn);
 293         if (useChecksum) {
 294                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
 295                 stream->readback(checksumBuf.get(), checksumSize);
 296                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
 297                         ALOGE("glGetClipPlanef: GL communication error, please report this issue to b.android.com.\n");
 298                         abort();
 299                 }
 300         }
 301 }
 302
 303 void glGetFloatv_enc(void *self , GLenum pname, GLfloat* params)
 304 {
 305
 306         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 307         IOStream *stream = ctx->m_stream;
 308         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 309         bool useChecksum = checksumCalculator->getVersion() > 0;
 310
 311         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
 312          unsigned char *ptr;
 313          unsigned char *buf;
 314          const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4;
 315          const size_t checksumSize = checksumCalculator->checksumByteSize();
 316          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 317         buf = stream->alloc(totalSize);
 318         ptr = buf;
 319         int tmp = OP_glGetFloatv;memcpy(ptr, &tmp, 4); ptr += 4;
 320         memcpy(ptr, &totalSize, 4);  ptr += 4;
 321
 322                 memcpy(ptr, &pname, 4); ptr += 4;
 323         *(unsigned int *)(ptr) = __size_params; ptr += 4;
 324
 325         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 326         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 327
 328         stream->readback(params, __size_params);
 329         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
 330         if (useChecksum) {
 331                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
 332                 stream->readback(checksumBuf.get(), checksumSize);
 333                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
 334                         ALOGE("glGetFloatv: GL communication error, please report this issue to b.android.com.\n");
 335                         abort();
 336                 }
 337         }
 338 }
 339
 340 void glGetLightfv_enc(void *self , GLenum light, GLenum pname, GLfloat* params)
 341 {
 342
 343         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 344         IOStream *stream = ctx->m_stream;
 345         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 346         bool useChecksum = checksumCalculator->getVersion() > 0;
 347
 348         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
 349          unsigned char *ptr;
 350          unsigned char *buf;
 351          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
 352          const size_t checksumSize = checksumCalculator->checksumByteSize();
 353          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 354         buf = stream->alloc(totalSize);
 355         ptr = buf;
 356         int tmp = OP_glGetLightfv;memcpy(ptr, &tmp, 4); ptr += 4;
 357         memcpy(ptr, &totalSize, 4);  ptr += 4;
 358
 359                 memcpy(ptr, &light, 4); ptr += 4;
 360                 memcpy(ptr, &pname, 4); ptr += 4;
 361         *(unsigned int *)(ptr) = __size_params; ptr += 4;
 362
 363         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 364         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 365
 366         stream->readback(params, __size_params);
 367         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
 368         if (useChecksum) {
 369                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
 370                 stream->readback(checksumBuf.get(), checksumSize);
 371                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
 372                         ALOGE("glGetLightfv: GL communication error, please report this issue to b.android.com.\n");
 373                         abort();
 374                 }
 375         }
 376 }
 377
 378 void glGetMaterialfv_enc(void *self , GLenum face, GLenum pname, GLfloat* params)
 379 {
 380
 381         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 382         IOStream *stream = ctx->m_stream;
 383         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 384         bool useChecksum = checksumCalculator->getVersion() > 0;
 385
 386         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
 387          unsigned char *ptr;
 388          unsigned char *buf;
 389          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
 390          const size_t checksumSize = checksumCalculator->checksumByteSize();
 391          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 392         buf = stream->alloc(totalSize);
 393         ptr = buf;
 394         int tmp = OP_glGetMaterialfv;memcpy(ptr, &tmp, 4); ptr += 4;
 395         memcpy(ptr, &totalSize, 4);  ptr += 4;
 396
 397                 memcpy(ptr, &face, 4); ptr += 4;
 398                 memcpy(ptr, &pname, 4); ptr += 4;
 399         *(unsigned int *)(ptr) = __size_params; ptr += 4;
 400
 401         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 402         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 403
 404         stream->readback(params, __size_params);
 405         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
 406         if (useChecksum) {
 407                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
 408                 stream->readback(checksumBuf.get(), checksumSize);
 409                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
 410                         ALOGE("glGetMaterialfv: GL communication error, please report this issue to b.android.com.\n");
 411                         abort();
 412                 }
 413         }
 414 }
 415
 416 void glGetTexEnvfv_enc(void *self , GLenum env, GLenum pname, GLfloat* params)
 417 {
 418
 419         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 420         IOStream *stream = ctx->m_stream;
 421         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 422         bool useChecksum = checksumCalculator->getVersion() > 0;
 423
 424         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
 425          unsigned char *ptr;
 426          unsigned char *buf;
 427          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
 428          const size_t checksumSize = checksumCalculator->checksumByteSize();
 429          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 430         buf = stream->alloc(totalSize);
 431         ptr = buf;
 432         int tmp = OP_glGetTexEnvfv;memcpy(ptr, &tmp, 4); ptr += 4;
 433         memcpy(ptr, &totalSize, 4);  ptr += 4;
 434
 435                 memcpy(ptr, &env, 4); ptr += 4;
 436                 memcpy(ptr, &pname, 4); ptr += 4;
 437         *(unsigned int *)(ptr) = __size_params; ptr += 4;
 438
 439         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 440         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 441
 442         stream->readback(params, __size_params);
 443         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
 444         if (useChecksum) {
 445                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
 446                 stream->readback(checksumBuf.get(), checksumSize);
 447                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
 448                         ALOGE("glGetTexEnvfv: GL communication error, please report this issue to b.android.com.\n");
 449                         abort();
 450                 }
 451         }
 452 }
 453
 454 void glGetTexParameterfv_enc(void *self , GLenum target, GLenum pname, GLfloat* params)
 455 {
 456
 457         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 458         IOStream *stream = ctx->m_stream;
 459         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 460         bool useChecksum = checksumCalculator->getVersion() > 0;
 461
 462         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
 463          unsigned char *ptr;
 464          unsigned char *buf;
 465          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
 466          const size_t checksumSize = checksumCalculator->checksumByteSize();
 467          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 468         buf = stream->alloc(totalSize);
 469         ptr = buf;
 470         int tmp = OP_glGetTexParameterfv;memcpy(ptr, &tmp, 4); ptr += 4;
 471         memcpy(ptr, &totalSize, 4);  ptr += 4;
 472
 473                 memcpy(ptr, &target, 4); ptr += 4;
 474                 memcpy(ptr, &pname, 4); ptr += 4;
 475         *(unsigned int *)(ptr) = __size_params; ptr += 4;
 476
 477         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 478         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 479
 480         stream->readback(params, __size_params);
 481         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
 482         if (useChecksum) {
 483                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
 484                 stream->readback(checksumBuf.get(), checksumSize);
 485                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
 486                         ALOGE("glGetTexParameterfv: GL communication error, please report this issue to b.android.com.\n");
 487                         abort();
 488                 }
 489         }
 490 }
 491
 492 void glLightModelf_enc(void *self , GLenum pname, GLfloat param)
 493 {
 494
 495         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 496         IOStream *stream = ctx->m_stream;
 497         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 498         bool useChecksum = checksumCalculator->getVersion() > 0;
 499
 500          unsigned char *ptr;
 501          unsigned char *buf;
 502          const size_t sizeWithoutChecksum = 8 + 4 + 4;
 503          const size_t checksumSize = checksumCalculator->checksumByteSize();
 504          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 505         buf = stream->alloc(totalSize);
 506         ptr = buf;
 507         int tmp = OP_glLightModelf;memcpy(ptr, &tmp, 4); ptr += 4;
 508         memcpy(ptr, &totalSize, 4);  ptr += 4;
 509
 510                 memcpy(ptr, &pname, 4); ptr += 4;
 511                 memcpy(ptr, &param, 4); ptr += 4;
 512
 513         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 514         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 515
 516 }
 517
 518 void glLightModelfv_enc(void *self , GLenum pname, const GLfloat* params)
 519 {
 520
 521         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 522         IOStream *stream = ctx->m_stream;
 523         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 524         bool useChecksum = checksumCalculator->getVersion() > 0;
 525
 526         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
 527          unsigned char *ptr;
 528          unsigned char *buf;
 529          const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4;
 530          const size_t checksumSize = checksumCalculator->checksumByteSize();
 531          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 532         buf = stream->alloc(totalSize);
 533         ptr = buf;
 534         int tmp = OP_glLightModelfv;memcpy(ptr, &tmp, 4); ptr += 4;
 535         memcpy(ptr, &totalSize, 4);  ptr += 4;
 536
 537                 memcpy(ptr, &pname, 4); ptr += 4;
 538         *(unsigned int *)(ptr) = __size_params; ptr += 4;
 539         memcpy(ptr, params, __size_params);ptr += __size_params;
 540
 541         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 542         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 543
 544 }
 545
 546 void glLightf_enc(void *self , GLenum light, GLenum pname, GLfloat param)
 547 {
 548
 549         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 550         IOStream *stream = ctx->m_stream;
 551         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 552         bool useChecksum = checksumCalculator->getVersion() > 0;
 553
 554          unsigned char *ptr;
 555          unsigned char *buf;
 556          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
 557          const size_t checksumSize = checksumCalculator->checksumByteSize();
 558          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 559         buf = stream->alloc(totalSize);
 560         ptr = buf;
 561         int tmp = OP_glLightf;memcpy(ptr, &tmp, 4); ptr += 4;
 562         memcpy(ptr, &totalSize, 4);  ptr += 4;
 563
 564                 memcpy(ptr, &light, 4); ptr += 4;
 565                 memcpy(ptr, &pname, 4); ptr += 4;
 566                 memcpy(ptr, &param, 4); ptr += 4;
 567
 568         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 569         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 570
 571 }
 572
 573 void glLightfv_enc(void *self , GLenum light, GLenum pname, const GLfloat* params)
 574 {
 575
 576         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 577         IOStream *stream = ctx->m_stream;
 578         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 579         bool useChecksum = checksumCalculator->getVersion() > 0;
 580
 581         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
 582          unsigned char *ptr;
 583          unsigned char *buf;
 584          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
 585          const size_t checksumSize = checksumCalculator->checksumByteSize();
 586          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 587         buf = stream->alloc(totalSize);
 588         ptr = buf;
 589         int tmp = OP_glLightfv;memcpy(ptr, &tmp, 4); ptr += 4;
 590         memcpy(ptr, &totalSize, 4);  ptr += 4;
 591
 592                 memcpy(ptr, &light, 4); ptr += 4;
 593                 memcpy(ptr, &pname, 4); ptr += 4;
 594         *(unsigned int *)(ptr) = __size_params; ptr += 4;
 595         memcpy(ptr, params, __size_params);ptr += __size_params;
 596
 597         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 598         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 599
 600 }
 601
 602 void glLineWidth_enc(void *self , GLfloat width)
 603 {
 604
 605         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 606         IOStream *stream = ctx->m_stream;
 607         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 608         bool useChecksum = checksumCalculator->getVersion() > 0;
 609
 610          unsigned char *ptr;
 611          unsigned char *buf;
 612          const size_t sizeWithoutChecksum = 8 + 4;
 613          const size_t checksumSize = checksumCalculator->checksumByteSize();
 614          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 615         buf = stream->alloc(totalSize);
 616         ptr = buf;
 617         int tmp = OP_glLineWidth;memcpy(ptr, &tmp, 4); ptr += 4;
 618         memcpy(ptr, &totalSize, 4);  ptr += 4;
 619
 620                 memcpy(ptr, &width, 4); ptr += 4;
 621
 622         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 623         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 624
 625 }
 626
 627 void glLoadMatrixf_enc(void *self , const GLfloat* m)
 628 {
 629
 630         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 631         IOStream *stream = ctx->m_stream;
 632         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 633         bool useChecksum = checksumCalculator->getVersion() > 0;
 634
 635         const unsigned int __size_m =  (16 * sizeof(GLfloat));
 636          unsigned char *ptr;
 637          unsigned char *buf;
 638          const size_t sizeWithoutChecksum = 8 + __size_m + 1*4;
 639          const size_t checksumSize = checksumCalculator->checksumByteSize();
 640          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 641         buf = stream->alloc(totalSize);
 642         ptr = buf;
 643         int tmp = OP_glLoadMatrixf;memcpy(ptr, &tmp, 4); ptr += 4;
 644         memcpy(ptr, &totalSize, 4);  ptr += 4;
 645
 646         *(unsigned int *)(ptr) = __size_m; ptr += 4;
 647         memcpy(ptr, m, __size_m);ptr += __size_m;
 648
 649         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 650         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 651
 652 }
 653
 654 void glMaterialf_enc(void *self , GLenum face, GLenum pname, GLfloat param)
 655 {
 656
 657         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 658         IOStream *stream = ctx->m_stream;
 659         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 660         bool useChecksum = checksumCalculator->getVersion() > 0;
 661
 662          unsigned char *ptr;
 663          unsigned char *buf;
 664          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
 665          const size_t checksumSize = checksumCalculator->checksumByteSize();
 666          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 667         buf = stream->alloc(totalSize);
 668         ptr = buf;
 669         int tmp = OP_glMaterialf;memcpy(ptr, &tmp, 4); ptr += 4;
 670         memcpy(ptr, &totalSize, 4);  ptr += 4;
 671
 672                 memcpy(ptr, &face, 4); ptr += 4;
 673                 memcpy(ptr, &pname, 4); ptr += 4;
 674                 memcpy(ptr, &param, 4); ptr += 4;
 675
 676         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 677         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 678
 679 }
 680
 681 void glMaterialfv_enc(void *self , GLenum face, GLenum pname, const GLfloat* params)
 682 {
 683
 684         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 685         IOStream *stream = ctx->m_stream;
 686         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 687         bool useChecksum = checksumCalculator->getVersion() > 0;
 688
 689         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
 690          unsigned char *ptr;
 691          unsigned char *buf;
 692          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
 693          const size_t checksumSize = checksumCalculator->checksumByteSize();
 694          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 695         buf = stream->alloc(totalSize);
 696         ptr = buf;
 697         int tmp = OP_glMaterialfv;memcpy(ptr, &tmp, 4); ptr += 4;
 698         memcpy(ptr, &totalSize, 4);  ptr += 4;
 699
 700                 memcpy(ptr, &face, 4); ptr += 4;
 701                 memcpy(ptr, &pname, 4); ptr += 4;
 702         *(unsigned int *)(ptr) = __size_params; ptr += 4;
 703         memcpy(ptr, params, __size_params);ptr += __size_params;
 704
 705         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 706         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 707
 708 }
 709
 710 void glMultMatrixf_enc(void *self , const GLfloat* m)
 711 {
 712
 713         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 714         IOStream *stream = ctx->m_stream;
 715         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 716         bool useChecksum = checksumCalculator->getVersion() > 0;
 717
 718         const unsigned int __size_m =  (16 * sizeof(GLfloat));
 719          unsigned char *ptr;
 720          unsigned char *buf;
 721          const size_t sizeWithoutChecksum = 8 + __size_m + 1*4;
 722          const size_t checksumSize = checksumCalculator->checksumByteSize();
 723          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 724         buf = stream->alloc(totalSize);
 725         ptr = buf;
 726         int tmp = OP_glMultMatrixf;memcpy(ptr, &tmp, 4); ptr += 4;
 727         memcpy(ptr, &totalSize, 4);  ptr += 4;
 728
 729         *(unsigned int *)(ptr) = __size_m; ptr += 4;
 730         memcpy(ptr, m, __size_m);ptr += __size_m;
 731
 732         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 733         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 734
 735 }
 736
 737 void glMultiTexCoord4f_enc(void *self , GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 738 {
 739
 740         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 741         IOStream *stream = ctx->m_stream;
 742         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 743         bool useChecksum = checksumCalculator->getVersion() > 0;
 744
 745          unsigned char *ptr;
 746          unsigned char *buf;
 747          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
 748          const size_t checksumSize = checksumCalculator->checksumByteSize();
 749          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 750         buf = stream->alloc(totalSize);
 751         ptr = buf;
 752         int tmp = OP_glMultiTexCoord4f;memcpy(ptr, &tmp, 4); ptr += 4;
 753         memcpy(ptr, &totalSize, 4);  ptr += 4;
 754
 755                 memcpy(ptr, &target, 4); ptr += 4;
 756                 memcpy(ptr, &s, 4); ptr += 4;
 757                 memcpy(ptr, &t, 4); ptr += 4;
 758                 memcpy(ptr, &r, 4); ptr += 4;
 759                 memcpy(ptr, &q, 4); ptr += 4;
 760
 761         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 762         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 763
 764 }
 765
 766 void glNormal3f_enc(void *self , GLfloat nx, GLfloat ny, GLfloat nz)
 767 {
 768
 769         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 770         IOStream *stream = ctx->m_stream;
 771         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 772         bool useChecksum = checksumCalculator->getVersion() > 0;
 773
 774          unsigned char *ptr;
 775          unsigned char *buf;
 776          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
 777          const size_t checksumSize = checksumCalculator->checksumByteSize();
 778          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 779         buf = stream->alloc(totalSize);
 780         ptr = buf;
 781         int tmp = OP_glNormal3f;memcpy(ptr, &tmp, 4); ptr += 4;
 782         memcpy(ptr, &totalSize, 4);  ptr += 4;
 783
 784                 memcpy(ptr, &nx, 4); ptr += 4;
 785                 memcpy(ptr, &ny, 4); ptr += 4;
 786                 memcpy(ptr, &nz, 4); ptr += 4;
 787
 788         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 789         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 790
 791 }
 792
 793 void glOrthof_enc(void *self , GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 794 {
 795
 796         gl_encoder_context_t *ctx = (gl_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 + 4 + 4 + 4 + 4 + 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_glOrthof;memcpy(ptr, &tmp, 4); ptr += 4;
 809         memcpy(ptr, &totalSize, 4);  ptr += 4;
 810
 811                 memcpy(ptr, &left, 4); ptr += 4;
 812                 memcpy(ptr, &right, 4); ptr += 4;
 813                 memcpy(ptr, &bottom, 4); ptr += 4;
 814                 memcpy(ptr, &top, 4); ptr += 4;
 815                 memcpy(ptr, &zNear, 4); ptr += 4;
 816                 memcpy(ptr, &zFar, 4); ptr += 4;
 817
 818         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 819         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 820
 821 }
 822
 823 void glPointParameterf_enc(void *self , GLenum pname, GLfloat param)
 824 {
 825
 826         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 827         IOStream *stream = ctx->m_stream;
 828         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 829         bool useChecksum = checksumCalculator->getVersion() > 0;
 830
 831          unsigned char *ptr;
 832          unsigned char *buf;
 833          const size_t sizeWithoutChecksum = 8 + 4 + 4;
 834          const size_t checksumSize = checksumCalculator->checksumByteSize();
 835          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 836         buf = stream->alloc(totalSize);
 837         ptr = buf;
 838         int tmp = OP_glPointParameterf;memcpy(ptr, &tmp, 4); ptr += 4;
 839         memcpy(ptr, &totalSize, 4);  ptr += 4;
 840
 841                 memcpy(ptr, &pname, 4); ptr += 4;
 842                 memcpy(ptr, &param, 4); ptr += 4;
 843
 844         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 845         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 846
 847 }
 848
 849 void glPointParameterfv_enc(void *self , GLenum pname, const GLfloat* params)
 850 {
 851
 852         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 853         IOStream *stream = ctx->m_stream;
 854         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 855         bool useChecksum = checksumCalculator->getVersion() > 0;
 856
 857         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
 858          unsigned char *ptr;
 859          unsigned char *buf;
 860          const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4;
 861          const size_t checksumSize = checksumCalculator->checksumByteSize();
 862          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 863         buf = stream->alloc(totalSize);
 864         ptr = buf;
 865         int tmp = OP_glPointParameterfv;memcpy(ptr, &tmp, 4); ptr += 4;
 866         memcpy(ptr, &totalSize, 4);  ptr += 4;
 867
 868                 memcpy(ptr, &pname, 4); ptr += 4;
 869         *(unsigned int *)(ptr) = __size_params; ptr += 4;
 870         memcpy(ptr, params, __size_params);ptr += __size_params;
 871
 872         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 873         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 874
 875 }
 876
 877 void glPointSize_enc(void *self , GLfloat size)
 878 {
 879
 880         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 881         IOStream *stream = ctx->m_stream;
 882         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 883         bool useChecksum = checksumCalculator->getVersion() > 0;
 884
 885          unsigned char *ptr;
 886          unsigned char *buf;
 887          const size_t sizeWithoutChecksum = 8 + 4;
 888          const size_t checksumSize = checksumCalculator->checksumByteSize();
 889          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 890         buf = stream->alloc(totalSize);
 891         ptr = buf;
 892         int tmp = OP_glPointSize;memcpy(ptr, &tmp, 4); ptr += 4;
 893         memcpy(ptr, &totalSize, 4);  ptr += 4;
 894
 895                 memcpy(ptr, &size, 4); ptr += 4;
 896
 897         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 898         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 899
 900 }
 901
 902 void glPolygonOffset_enc(void *self , GLfloat factor, GLfloat units)
 903 {
 904
 905         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 906         IOStream *stream = ctx->m_stream;
 907         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 908         bool useChecksum = checksumCalculator->getVersion() > 0;
 909
 910          unsigned char *ptr;
 911          unsigned char *buf;
 912          const size_t sizeWithoutChecksum = 8 + 4 + 4;
 913          const size_t checksumSize = checksumCalculator->checksumByteSize();
 914          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 915         buf = stream->alloc(totalSize);
 916         ptr = buf;
 917         int tmp = OP_glPolygonOffset;memcpy(ptr, &tmp, 4); ptr += 4;
 918         memcpy(ptr, &totalSize, 4);  ptr += 4;
 919
 920                 memcpy(ptr, &factor, 4); ptr += 4;
 921                 memcpy(ptr, &units, 4); ptr += 4;
 922
 923         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 924         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 925
 926 }
 927
 928 void glRotatef_enc(void *self , GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 929 {
 930
 931         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 932         IOStream *stream = ctx->m_stream;
 933         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 934         bool useChecksum = checksumCalculator->getVersion() > 0;
 935
 936          unsigned char *ptr;
 937          unsigned char *buf;
 938          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
 939          const size_t checksumSize = checksumCalculator->checksumByteSize();
 940          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 941         buf = stream->alloc(totalSize);
 942         ptr = buf;
 943         int tmp = OP_glRotatef;memcpy(ptr, &tmp, 4); ptr += 4;
 944         memcpy(ptr, &totalSize, 4);  ptr += 4;
 945
 946                 memcpy(ptr, &angle, 4); ptr += 4;
 947                 memcpy(ptr, &x, 4); ptr += 4;
 948                 memcpy(ptr, &y, 4); ptr += 4;
 949                 memcpy(ptr, &z, 4); ptr += 4;
 950
 951         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 952         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 953
 954 }
 955
 956 void glScalef_enc(void *self , GLfloat x, GLfloat y, GLfloat z)
 957 {
 958
 959         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 960         IOStream *stream = ctx->m_stream;
 961         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 962         bool useChecksum = checksumCalculator->getVersion() > 0;
 963
 964          unsigned char *ptr;
 965          unsigned char *buf;
 966          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
 967          const size_t checksumSize = checksumCalculator->checksumByteSize();
 968          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 969         buf = stream->alloc(totalSize);
 970         ptr = buf;
 971         int tmp = OP_glScalef;memcpy(ptr, &tmp, 4); ptr += 4;
 972         memcpy(ptr, &totalSize, 4);  ptr += 4;
 973
 974                 memcpy(ptr, &x, 4); ptr += 4;
 975                 memcpy(ptr, &y, 4); ptr += 4;
 976                 memcpy(ptr, &z, 4); ptr += 4;
 977
 978         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
 979         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
 980
 981 }
 982
 983 void glTexEnvf_enc(void *self , GLenum target, GLenum pname, GLfloat param)
 984 {
 985
 986         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 987         IOStream *stream = ctx->m_stream;
 988         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
 989         bool useChecksum = checksumCalculator->getVersion() > 0;
 990
 991          unsigned char *ptr;
 992          unsigned char *buf;
 993          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
 994          const size_t checksumSize = checksumCalculator->checksumByteSize();
 995          const size_t totalSize = sizeWithoutChecksum + checksumSize;
 996         buf = stream->alloc(totalSize);
 997         ptr = buf;
 998         int tmp = OP_glTexEnvf;memcpy(ptr, &tmp, 4); ptr += 4;
 999         memcpy(ptr, &totalSize, 4);  ptr += 4;
1000
1001                 memcpy(ptr, &target, 4); ptr += 4;
1002                 memcpy(ptr, &pname, 4); ptr += 4;
1003                 memcpy(ptr, &param, 4); ptr += 4;
1004
1005         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1006         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1007
1008 }
1009
1010 void glTexEnvfv_enc(void *self , GLenum target, GLenum pname, const GLfloat* params)
1011 {
1012
1013         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1014         IOStream *stream = ctx->m_stream;
1015         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1016         bool useChecksum = checksumCalculator->getVersion() > 0;
1017
1018         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
1019          unsigned char *ptr;
1020          unsigned char *buf;
1021          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
1022          const size_t checksumSize = checksumCalculator->checksumByteSize();
1023          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1024         buf = stream->alloc(totalSize);
1025         ptr = buf;
1026         int tmp = OP_glTexEnvfv;memcpy(ptr, &tmp, 4); ptr += 4;
1027         memcpy(ptr, &totalSize, 4);  ptr += 4;
1028
1029                 memcpy(ptr, &target, 4); ptr += 4;
1030                 memcpy(ptr, &pname, 4); ptr += 4;
1031         *(unsigned int *)(ptr) = __size_params; ptr += 4;
1032         memcpy(ptr, params, __size_params);ptr += __size_params;
1033
1034         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1035         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1036
1037 }
1038
1039 void glTexParameterf_enc(void *self , GLenum target, GLenum pname, GLfloat param)
1040 {
1041
1042         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1043         IOStream *stream = ctx->m_stream;
1044         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1045         bool useChecksum = checksumCalculator->getVersion() > 0;
1046
1047          unsigned char *ptr;
1048          unsigned char *buf;
1049          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
1050          const size_t checksumSize = checksumCalculator->checksumByteSize();
1051          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1052         buf = stream->alloc(totalSize);
1053         ptr = buf;
1054         int tmp = OP_glTexParameterf;memcpy(ptr, &tmp, 4); ptr += 4;
1055         memcpy(ptr, &totalSize, 4);  ptr += 4;
1056
1057                 memcpy(ptr, &target, 4); ptr += 4;
1058                 memcpy(ptr, &pname, 4); ptr += 4;
1059                 memcpy(ptr, &param, 4); ptr += 4;
1060
1061         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1062         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1063
1064 }
1065
1066 void glTexParameterfv_enc(void *self , GLenum target, GLenum pname, const GLfloat* params)
1067 {
1068
1069         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1070         IOStream *stream = ctx->m_stream;
1071         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1072         bool useChecksum = checksumCalculator->getVersion() > 0;
1073
1074         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
1075          unsigned char *ptr;
1076          unsigned char *buf;
1077          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
1078          const size_t checksumSize = checksumCalculator->checksumByteSize();
1079          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1080         buf = stream->alloc(totalSize);
1081         ptr = buf;
1082         int tmp = OP_glTexParameterfv;memcpy(ptr, &tmp, 4); ptr += 4;
1083         memcpy(ptr, &totalSize, 4);  ptr += 4;
1084
1085                 memcpy(ptr, &target, 4); ptr += 4;
1086                 memcpy(ptr, &pname, 4); ptr += 4;
1087         *(unsigned int *)(ptr) = __size_params; ptr += 4;
1088         memcpy(ptr, params, __size_params);ptr += __size_params;
1089
1090         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1091         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1092
1093 }
1094
1095 void glTranslatef_enc(void *self , GLfloat x, GLfloat y, GLfloat z)
1096 {
1097
1098         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1099         IOStream *stream = ctx->m_stream;
1100         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1101         bool useChecksum = checksumCalculator->getVersion() > 0;
1102
1103          unsigned char *ptr;
1104          unsigned char *buf;
1105          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
1106          const size_t checksumSize = checksumCalculator->checksumByteSize();
1107          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1108         buf = stream->alloc(totalSize);
1109         ptr = buf;
1110         int tmp = OP_glTranslatef;memcpy(ptr, &tmp, 4); ptr += 4;
1111         memcpy(ptr, &totalSize, 4);  ptr += 4;
1112
1113                 memcpy(ptr, &x, 4); ptr += 4;
1114                 memcpy(ptr, &y, 4); ptr += 4;
1115                 memcpy(ptr, &z, 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 glActiveTexture_enc(void *self , GLenum texture)
1123 {
1124
1125         gl_encoder_context_t *ctx = (gl_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_glActiveTexture;memcpy(ptr, &tmp, 4); ptr += 4;
1138         memcpy(ptr, &totalSize, 4);  ptr += 4;
1139
1140                 memcpy(ptr, &texture, 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 glAlphaFuncx_enc(void *self , GLenum func, GLclampx ref)
1148 {
1149
1150         gl_encoder_context_t *ctx = (gl_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 + 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_glAlphaFuncx;memcpy(ptr, &tmp, 4); ptr += 4;
1163         memcpy(ptr, &totalSize, 4);  ptr += 4;
1164
1165                 memcpy(ptr, &func, 4); ptr += 4;
1166                 memcpy(ptr, &ref, 4); ptr += 4;
1167
1168         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1169         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1170
1171 }
1172
1173 void glBindBuffer_enc(void *self , GLenum target, GLuint buffer)
1174 {
1175
1176         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1177         IOStream *stream = ctx->m_stream;
1178         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1179         bool useChecksum = checksumCalculator->getVersion() > 0;
1180
1181          unsigned char *ptr;
1182          unsigned char *buf;
1183          const size_t sizeWithoutChecksum = 8 + 4 + 4;
1184          const size_t checksumSize = checksumCalculator->checksumByteSize();
1185          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1186         buf = stream->alloc(totalSize);
1187         ptr = buf;
1188         int tmp = OP_glBindBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
1189         memcpy(ptr, &totalSize, 4);  ptr += 4;
1190
1191                 memcpy(ptr, &target, 4); ptr += 4;
1192                 memcpy(ptr, &buffer, 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 glBindTexture_enc(void *self , GLenum target, GLuint texture)
1200 {
1201
1202         gl_encoder_context_t *ctx = (gl_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 + 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_glBindTexture;memcpy(ptr, &tmp, 4); ptr += 4;
1215         memcpy(ptr, &totalSize, 4);  ptr += 4;
1216
1217                 memcpy(ptr, &target, 4); ptr += 4;
1218                 memcpy(ptr, &texture, 4); ptr += 4;
1219
1220         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1221         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1222
1223 }
1224
1225 void glBlendFunc_enc(void *self , GLenum sfactor, GLenum dfactor)
1226 {
1227
1228         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1229         IOStream *stream = ctx->m_stream;
1230         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1231         bool useChecksum = checksumCalculator->getVersion() > 0;
1232
1233          unsigned char *ptr;
1234          unsigned char *buf;
1235          const size_t sizeWithoutChecksum = 8 + 4 + 4;
1236          const size_t checksumSize = checksumCalculator->checksumByteSize();
1237          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1238         buf = stream->alloc(totalSize);
1239         ptr = buf;
1240         int tmp = OP_glBlendFunc;memcpy(ptr, &tmp, 4); ptr += 4;
1241         memcpy(ptr, &totalSize, 4);  ptr += 4;
1242
1243                 memcpy(ptr, &sfactor, 4); ptr += 4;
1244                 memcpy(ptr, &dfactor, 4); ptr += 4;
1245
1246         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1247         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1248
1249 }
1250
1251 void glBufferData_enc(void *self , GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
1252 {
1253
1254         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1255         IOStream *stream = ctx->m_stream;
1256         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1257         bool useChecksum = checksumCalculator->getVersion() > 0;
1258
1259         const unsigned int __size_data = ((data != NULL) ?  size : 0);
1260          unsigned char *ptr;
1261          unsigned char *buf;
1262          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_data + 4 + 1*4;
1263          const size_t checksumSize = checksumCalculator->checksumByteSize();
1264          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1265         buf = stream->alloc(totalSize);
1266         ptr = buf;
1267         int tmp = OP_glBufferData;memcpy(ptr, &tmp, 4); ptr += 4;
1268         memcpy(ptr, &totalSize, 4);  ptr += 4;
1269
1270                 memcpy(ptr, &target, 4); ptr += 4;
1271                 memcpy(ptr, &size, 4); ptr += 4;
1272         *(unsigned int *)(ptr) = __size_data; ptr += 4;
1273         if (data != NULL) memcpy(ptr, data, __size_data);ptr += __size_data;
1274                 memcpy(ptr, &usage, 4); ptr += 4;
1275
1276         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1277         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1278
1279 }
1280
1281 void glBufferSubData_enc(void *self , GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
1282 {
1283
1284         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1285         IOStream *stream = ctx->m_stream;
1286         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1287         bool useChecksum = checksumCalculator->getVersion() > 0;
1288
1289         const unsigned int __size_data = ((data != NULL) ?  size : 0);
1290          unsigned char *ptr;
1291          unsigned char *buf;
1292          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_data + 1*4;
1293          const size_t checksumSize = checksumCalculator->checksumByteSize();
1294          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1295         buf = stream->alloc(totalSize);
1296         ptr = buf;
1297         int tmp = OP_glBufferSubData;memcpy(ptr, &tmp, 4); ptr += 4;
1298         memcpy(ptr, &totalSize, 4);  ptr += 4;
1299
1300                 memcpy(ptr, &target, 4); ptr += 4;
1301                 memcpy(ptr, &offset, 4); ptr += 4;
1302                 memcpy(ptr, &size, 4); ptr += 4;
1303         *(unsigned int *)(ptr) = __size_data; ptr += 4;
1304         if (data != NULL) memcpy(ptr, data, __size_data);ptr += __size_data;
1305
1306         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1307         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1308
1309 }
1310
1311 void glClear_enc(void *self , GLbitfield mask)
1312 {
1313
1314         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1315         IOStream *stream = ctx->m_stream;
1316         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1317         bool useChecksum = checksumCalculator->getVersion() > 0;
1318
1319          unsigned char *ptr;
1320          unsigned char *buf;
1321          const size_t sizeWithoutChecksum = 8 + 4;
1322          const size_t checksumSize = checksumCalculator->checksumByteSize();
1323          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1324         buf = stream->alloc(totalSize);
1325         ptr = buf;
1326         int tmp = OP_glClear;memcpy(ptr, &tmp, 4); ptr += 4;
1327         memcpy(ptr, &totalSize, 4);  ptr += 4;
1328
1329                 memcpy(ptr, &mask, 4); ptr += 4;
1330
1331         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1332         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1333
1334 }
1335
1336 void glClearColorx_enc(void *self , GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
1337 {
1338
1339         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1340         IOStream *stream = ctx->m_stream;
1341         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1342         bool useChecksum = checksumCalculator->getVersion() > 0;
1343
1344          unsigned char *ptr;
1345          unsigned char *buf;
1346          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
1347          const size_t checksumSize = checksumCalculator->checksumByteSize();
1348          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1349         buf = stream->alloc(totalSize);
1350         ptr = buf;
1351         int tmp = OP_glClearColorx;memcpy(ptr, &tmp, 4); ptr += 4;
1352         memcpy(ptr, &totalSize, 4);  ptr += 4;
1353
1354                 memcpy(ptr, &red, 4); ptr += 4;
1355                 memcpy(ptr, &green, 4); ptr += 4;
1356                 memcpy(ptr, &blue, 4); ptr += 4;
1357                 memcpy(ptr, &alpha, 4); ptr += 4;
1358
1359         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1360         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1361
1362 }
1363
1364 void glClearDepthx_enc(void *self , GLclampx depth)
1365 {
1366
1367         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1368         IOStream *stream = ctx->m_stream;
1369         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1370         bool useChecksum = checksumCalculator->getVersion() > 0;
1371
1372          unsigned char *ptr;
1373          unsigned char *buf;
1374          const size_t sizeWithoutChecksum = 8 + 4;
1375          const size_t checksumSize = checksumCalculator->checksumByteSize();
1376          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1377         buf = stream->alloc(totalSize);
1378         ptr = buf;
1379         int tmp = OP_glClearDepthx;memcpy(ptr, &tmp, 4); ptr += 4;
1380         memcpy(ptr, &totalSize, 4);  ptr += 4;
1381
1382                 memcpy(ptr, &depth, 4); ptr += 4;
1383
1384         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1385         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1386
1387 }
1388
1389 void glClearStencil_enc(void *self , GLint s)
1390 {
1391
1392         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1393         IOStream *stream = ctx->m_stream;
1394         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1395         bool useChecksum = checksumCalculator->getVersion() > 0;
1396
1397          unsigned char *ptr;
1398          unsigned char *buf;
1399          const size_t sizeWithoutChecksum = 8 + 4;
1400          const size_t checksumSize = checksumCalculator->checksumByteSize();
1401          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1402         buf = stream->alloc(totalSize);
1403         ptr = buf;
1404         int tmp = OP_glClearStencil;memcpy(ptr, &tmp, 4); ptr += 4;
1405         memcpy(ptr, &totalSize, 4);  ptr += 4;
1406
1407                 memcpy(ptr, &s, 4); ptr += 4;
1408
1409         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1410         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1411
1412 }
1413
1414 void glClientActiveTexture_enc(void *self , GLenum texture)
1415 {
1416
1417         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1418         IOStream *stream = ctx->m_stream;
1419         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1420         bool useChecksum = checksumCalculator->getVersion() > 0;
1421
1422          unsigned char *ptr;
1423          unsigned char *buf;
1424          const size_t sizeWithoutChecksum = 8 + 4;
1425          const size_t checksumSize = checksumCalculator->checksumByteSize();
1426          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1427         buf = stream->alloc(totalSize);
1428         ptr = buf;
1429         int tmp = OP_glClientActiveTexture;memcpy(ptr, &tmp, 4); ptr += 4;
1430         memcpy(ptr, &totalSize, 4);  ptr += 4;
1431
1432                 memcpy(ptr, &texture, 4); ptr += 4;
1433
1434         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1435         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1436
1437 }
1438
1439 void glColor4ub_enc(void *self , GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
1440 {
1441
1442         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1443         IOStream *stream = ctx->m_stream;
1444         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1445         bool useChecksum = checksumCalculator->getVersion() > 0;
1446
1447          unsigned char *ptr;
1448          unsigned char *buf;
1449          const size_t sizeWithoutChecksum = 8 + 1 + 1 + 1 + 1;
1450          const size_t checksumSize = checksumCalculator->checksumByteSize();
1451          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1452         buf = stream->alloc(totalSize);
1453         ptr = buf;
1454         int tmp = OP_glColor4ub;memcpy(ptr, &tmp, 4); ptr += 4;
1455         memcpy(ptr, &totalSize, 4);  ptr += 4;
1456
1457                 memcpy(ptr, &red, 1); ptr += 1;
1458                 memcpy(ptr, &green, 1); ptr += 1;
1459                 memcpy(ptr, &blue, 1); ptr += 1;
1460                 memcpy(ptr, &alpha, 1); ptr += 1;
1461
1462         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1463         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1464
1465 }
1466
1467 void glColor4x_enc(void *self , GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
1468 {
1469
1470         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1471         IOStream *stream = ctx->m_stream;
1472         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1473         bool useChecksum = checksumCalculator->getVersion() > 0;
1474
1475          unsigned char *ptr;
1476          unsigned char *buf;
1477          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
1478          const size_t checksumSize = checksumCalculator->checksumByteSize();
1479          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1480         buf = stream->alloc(totalSize);
1481         ptr = buf;
1482         int tmp = OP_glColor4x;memcpy(ptr, &tmp, 4); ptr += 4;
1483         memcpy(ptr, &totalSize, 4);  ptr += 4;
1484
1485                 memcpy(ptr, &red, 4); ptr += 4;
1486                 memcpy(ptr, &green, 4); ptr += 4;
1487                 memcpy(ptr, &blue, 4); ptr += 4;
1488                 memcpy(ptr, &alpha, 4); ptr += 4;
1489
1490         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1491         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1492
1493 }
1494
1495 void glColorMask_enc(void *self , GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
1496 {
1497
1498         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1499         IOStream *stream = ctx->m_stream;
1500         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1501         bool useChecksum = checksumCalculator->getVersion() > 0;
1502
1503          unsigned char *ptr;
1504          unsigned char *buf;
1505          const size_t sizeWithoutChecksum = 8 + 1 + 1 + 1 + 1;
1506          const size_t checksumSize = checksumCalculator->checksumByteSize();
1507          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1508         buf = stream->alloc(totalSize);
1509         ptr = buf;
1510         int tmp = OP_glColorMask;memcpy(ptr, &tmp, 4); ptr += 4;
1511         memcpy(ptr, &totalSize, 4);  ptr += 4;
1512
1513                 memcpy(ptr, &red, 1); ptr += 1;
1514                 memcpy(ptr, &green, 1); ptr += 1;
1515                 memcpy(ptr, &blue, 1); ptr += 1;
1516                 memcpy(ptr, &alpha, 1); ptr += 1;
1517
1518         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1519         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1520
1521 }
1522
1523 void glCompressedTexImage2D_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data)
1524 {
1525
1526         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1527         IOStream *stream = ctx->m_stream;
1528         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1529         bool useChecksum = checksumCalculator->getVersion() > 0;
1530
1531         const unsigned int __size_data = ((data != NULL) ?  imageSize : 0);
1532          unsigned char *ptr;
1533          unsigned char *buf;
1534          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_data + 1*4;
1535          const size_t checksumSize = checksumCalculator->checksumByteSize();
1536          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1537         buf = stream->alloc(totalSize);
1538         ptr = buf;
1539         int tmp = OP_glCompressedTexImage2D;memcpy(ptr, &tmp, 4); ptr += 4;
1540         memcpy(ptr, &totalSize, 4);  ptr += 4;
1541
1542                 memcpy(ptr, &target, 4); ptr += 4;
1543                 memcpy(ptr, &level, 4); ptr += 4;
1544                 memcpy(ptr, &internalformat, 4); ptr += 4;
1545                 memcpy(ptr, &width, 4); ptr += 4;
1546                 memcpy(ptr, &height, 4); ptr += 4;
1547                 memcpy(ptr, &border, 4); ptr += 4;
1548                 memcpy(ptr, &imageSize, 4); ptr += 4;
1549         *(unsigned int *)(ptr) = __size_data; ptr += 4;
1550         if (data != NULL) memcpy(ptr, data, __size_data);ptr += __size_data;
1551
1552         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1553         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1554
1555 }
1556
1557 void glCompressedTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data)
1558 {
1559
1560         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1561         IOStream *stream = ctx->m_stream;
1562         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1563         bool useChecksum = checksumCalculator->getVersion() > 0;
1564
1565         const unsigned int __size_data = ((data != NULL) ?  imageSize : 0);
1566          unsigned char *ptr;
1567          unsigned char *buf;
1568          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_data + 1*4;
1569          const size_t checksumSize = checksumCalculator->checksumByteSize();
1570          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1571         buf = stream->alloc(totalSize);
1572         ptr = buf;
1573         int tmp = OP_glCompressedTexSubImage2D;memcpy(ptr, &tmp, 4); ptr += 4;
1574         memcpy(ptr, &totalSize, 4);  ptr += 4;
1575
1576                 memcpy(ptr, &target, 4); ptr += 4;
1577                 memcpy(ptr, &level, 4); ptr += 4;
1578                 memcpy(ptr, &xoffset, 4); ptr += 4;
1579                 memcpy(ptr, &yoffset, 4); ptr += 4;
1580                 memcpy(ptr, &width, 4); ptr += 4;
1581                 memcpy(ptr, &height, 4); ptr += 4;
1582                 memcpy(ptr, &format, 4); ptr += 4;
1583                 memcpy(ptr, &imageSize, 4); ptr += 4;
1584         *(unsigned int *)(ptr) = __size_data; ptr += 4;
1585         if (data != NULL) memcpy(ptr, data, __size_data);ptr += __size_data;
1586
1587         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1588         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1589
1590 }
1591
1592 void glCopyTexImage2D_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
1593 {
1594
1595         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1596         IOStream *stream = ctx->m_stream;
1597         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1598         bool useChecksum = checksumCalculator->getVersion() > 0;
1599
1600          unsigned char *ptr;
1601          unsigned char *buf;
1602          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4;
1603          const size_t checksumSize = checksumCalculator->checksumByteSize();
1604          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1605         buf = stream->alloc(totalSize);
1606         ptr = buf;
1607         int tmp = OP_glCopyTexImage2D;memcpy(ptr, &tmp, 4); ptr += 4;
1608         memcpy(ptr, &totalSize, 4);  ptr += 4;
1609
1610                 memcpy(ptr, &target, 4); ptr += 4;
1611                 memcpy(ptr, &level, 4); ptr += 4;
1612                 memcpy(ptr, &internalformat, 4); ptr += 4;
1613                 memcpy(ptr, &x, 4); ptr += 4;
1614                 memcpy(ptr, &y, 4); ptr += 4;
1615                 memcpy(ptr, &width, 4); ptr += 4;
1616                 memcpy(ptr, &height, 4); ptr += 4;
1617                 memcpy(ptr, &border, 4); ptr += 4;
1618
1619         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1620         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1621
1622 }
1623
1624 void glCopyTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
1625 {
1626
1627         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1628         IOStream *stream = ctx->m_stream;
1629         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1630         bool useChecksum = checksumCalculator->getVersion() > 0;
1631
1632          unsigned char *ptr;
1633          unsigned char *buf;
1634          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4;
1635          const size_t checksumSize = checksumCalculator->checksumByteSize();
1636          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1637         buf = stream->alloc(totalSize);
1638         ptr = buf;
1639         int tmp = OP_glCopyTexSubImage2D;memcpy(ptr, &tmp, 4); ptr += 4;
1640         memcpy(ptr, &totalSize, 4);  ptr += 4;
1641
1642                 memcpy(ptr, &target, 4); ptr += 4;
1643                 memcpy(ptr, &level, 4); ptr += 4;
1644                 memcpy(ptr, &xoffset, 4); ptr += 4;
1645                 memcpy(ptr, &yoffset, 4); ptr += 4;
1646                 memcpy(ptr, &x, 4); ptr += 4;
1647                 memcpy(ptr, &y, 4); ptr += 4;
1648                 memcpy(ptr, &width, 4); ptr += 4;
1649                 memcpy(ptr, &height, 4); ptr += 4;
1650
1651         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1652         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1653
1654 }
1655
1656 void glCullFace_enc(void *self , GLenum mode)
1657 {
1658
1659         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1660         IOStream *stream = ctx->m_stream;
1661         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1662         bool useChecksum = checksumCalculator->getVersion() > 0;
1663
1664          unsigned char *ptr;
1665          unsigned char *buf;
1666          const size_t sizeWithoutChecksum = 8 + 4;
1667          const size_t checksumSize = checksumCalculator->checksumByteSize();
1668          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1669         buf = stream->alloc(totalSize);
1670         ptr = buf;
1671         int tmp = OP_glCullFace;memcpy(ptr, &tmp, 4); ptr += 4;
1672         memcpy(ptr, &totalSize, 4);  ptr += 4;
1673
1674                 memcpy(ptr, &mode, 4); ptr += 4;
1675
1676         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1677         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1678
1679 }
1680
1681 void glDeleteBuffers_enc(void *self , GLsizei n, const GLuint* buffers)
1682 {
1683
1684         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1685         IOStream *stream = ctx->m_stream;
1686         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1687         bool useChecksum = checksumCalculator->getVersion() > 0;
1688
1689         const unsigned int __size_buffers =  (n * sizeof(GLuint));
1690          unsigned char *ptr;
1691          unsigned char *buf;
1692          const size_t sizeWithoutChecksum = 8 + 4 + __size_buffers + 1*4;
1693          const size_t checksumSize = checksumCalculator->checksumByteSize();
1694          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1695         buf = stream->alloc(totalSize);
1696         ptr = buf;
1697         int tmp = OP_glDeleteBuffers;memcpy(ptr, &tmp, 4); ptr += 4;
1698         memcpy(ptr, &totalSize, 4);  ptr += 4;
1699
1700                 memcpy(ptr, &n, 4); ptr += 4;
1701         *(unsigned int *)(ptr) = __size_buffers; ptr += 4;
1702         memcpy(ptr, buffers, __size_buffers);ptr += __size_buffers;
1703
1704         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1705         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1706
1707 }
1708
1709 void glDeleteTextures_enc(void *self , GLsizei n, const GLuint* textures)
1710 {
1711
1712         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1713         IOStream *stream = ctx->m_stream;
1714         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1715         bool useChecksum = checksumCalculator->getVersion() > 0;
1716
1717         const unsigned int __size_textures =  (n * sizeof(GLuint));
1718          unsigned char *ptr;
1719          unsigned char *buf;
1720          const size_t sizeWithoutChecksum = 8 + 4 + __size_textures + 1*4;
1721          const size_t checksumSize = checksumCalculator->checksumByteSize();
1722          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1723         buf = stream->alloc(totalSize);
1724         ptr = buf;
1725         int tmp = OP_glDeleteTextures;memcpy(ptr, &tmp, 4); ptr += 4;
1726         memcpy(ptr, &totalSize, 4);  ptr += 4;
1727
1728                 memcpy(ptr, &n, 4); ptr += 4;
1729         *(unsigned int *)(ptr) = __size_textures; ptr += 4;
1730         memcpy(ptr, textures, __size_textures);ptr += __size_textures;
1731
1732         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1733         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1734
1735 }
1736
1737 void glDepthFunc_enc(void *self , GLenum func)
1738 {
1739
1740         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1741         IOStream *stream = ctx->m_stream;
1742         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1743         bool useChecksum = checksumCalculator->getVersion() > 0;
1744
1745          unsigned char *ptr;
1746          unsigned char *buf;
1747          const size_t sizeWithoutChecksum = 8 + 4;
1748          const size_t checksumSize = checksumCalculator->checksumByteSize();
1749          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1750         buf = stream->alloc(totalSize);
1751         ptr = buf;
1752         int tmp = OP_glDepthFunc;memcpy(ptr, &tmp, 4); ptr += 4;
1753         memcpy(ptr, &totalSize, 4);  ptr += 4;
1754
1755                 memcpy(ptr, &func, 4); ptr += 4;
1756
1757         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1758         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1759
1760 }
1761
1762 void glDepthMask_enc(void *self , GLboolean flag)
1763 {
1764
1765         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1766         IOStream *stream = ctx->m_stream;
1767         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1768         bool useChecksum = checksumCalculator->getVersion() > 0;
1769
1770          unsigned char *ptr;
1771          unsigned char *buf;
1772          const size_t sizeWithoutChecksum = 8 + 1;
1773          const size_t checksumSize = checksumCalculator->checksumByteSize();
1774          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1775         buf = stream->alloc(totalSize);
1776         ptr = buf;
1777         int tmp = OP_glDepthMask;memcpy(ptr, &tmp, 4); ptr += 4;
1778         memcpy(ptr, &totalSize, 4);  ptr += 4;
1779
1780                 memcpy(ptr, &flag, 1); ptr += 1;
1781
1782         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1783         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1784
1785 }
1786
1787 void glDepthRangex_enc(void *self , GLclampx zNear, GLclampx zFar)
1788 {
1789
1790         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1791         IOStream *stream = ctx->m_stream;
1792         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1793         bool useChecksum = checksumCalculator->getVersion() > 0;
1794
1795          unsigned char *ptr;
1796          unsigned char *buf;
1797          const size_t sizeWithoutChecksum = 8 + 4 + 4;
1798          const size_t checksumSize = checksumCalculator->checksumByteSize();
1799          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1800         buf = stream->alloc(totalSize);
1801         ptr = buf;
1802         int tmp = OP_glDepthRangex;memcpy(ptr, &tmp, 4); ptr += 4;
1803         memcpy(ptr, &totalSize, 4);  ptr += 4;
1804
1805                 memcpy(ptr, &zNear, 4); ptr += 4;
1806                 memcpy(ptr, &zFar, 4); ptr += 4;
1807
1808         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1809         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1810
1811 }
1812
1813 void glDisable_enc(void *self , GLenum cap)
1814 {
1815
1816         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1817         IOStream *stream = ctx->m_stream;
1818         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1819         bool useChecksum = checksumCalculator->getVersion() > 0;
1820
1821          unsigned char *ptr;
1822          unsigned char *buf;
1823          const size_t sizeWithoutChecksum = 8 + 4;
1824          const size_t checksumSize = checksumCalculator->checksumByteSize();
1825          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1826         buf = stream->alloc(totalSize);
1827         ptr = buf;
1828         int tmp = OP_glDisable;memcpy(ptr, &tmp, 4); ptr += 4;
1829         memcpy(ptr, &totalSize, 4);  ptr += 4;
1830
1831                 memcpy(ptr, &cap, 4); ptr += 4;
1832
1833         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1834         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1835
1836 }
1837
1838 void glDisableClientState_enc(void *self , GLenum array)
1839 {
1840
1841         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1842         IOStream *stream = ctx->m_stream;
1843         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1844         bool useChecksum = checksumCalculator->getVersion() > 0;
1845
1846          unsigned char *ptr;
1847          unsigned char *buf;
1848          const size_t sizeWithoutChecksum = 8 + 4;
1849          const size_t checksumSize = checksumCalculator->checksumByteSize();
1850          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1851         buf = stream->alloc(totalSize);
1852         ptr = buf;
1853         int tmp = OP_glDisableClientState;memcpy(ptr, &tmp, 4); ptr += 4;
1854         memcpy(ptr, &totalSize, 4);  ptr += 4;
1855
1856                 memcpy(ptr, &array, 4); ptr += 4;
1857
1858         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1859         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1860
1861 }
1862
1863 void glDrawArrays_enc(void *self , GLenum mode, GLint first, GLsizei count)
1864 {
1865
1866         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1867         IOStream *stream = ctx->m_stream;
1868         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1869         bool useChecksum = checksumCalculator->getVersion() > 0;
1870
1871          unsigned char *ptr;
1872          unsigned char *buf;
1873          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
1874          const size_t checksumSize = checksumCalculator->checksumByteSize();
1875          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1876         buf = stream->alloc(totalSize);
1877         ptr = buf;
1878         int tmp = OP_glDrawArrays;memcpy(ptr, &tmp, 4); ptr += 4;
1879         memcpy(ptr, &totalSize, 4);  ptr += 4;
1880
1881                 memcpy(ptr, &mode, 4); ptr += 4;
1882                 memcpy(ptr, &first, 4); ptr += 4;
1883                 memcpy(ptr, &count, 4); ptr += 4;
1884
1885         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1886         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1887
1888 }
1889
1890 void glEnable_enc(void *self , GLenum cap)
1891 {
1892
1893         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1894         IOStream *stream = ctx->m_stream;
1895         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1896         bool useChecksum = checksumCalculator->getVersion() > 0;
1897
1898          unsigned char *ptr;
1899          unsigned char *buf;
1900          const size_t sizeWithoutChecksum = 8 + 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_glEnable;memcpy(ptr, &tmp, 4); ptr += 4;
1906         memcpy(ptr, &totalSize, 4);  ptr += 4;
1907
1908                 memcpy(ptr, &cap, 4); ptr += 4;
1909
1910         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1911         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1912
1913 }
1914
1915 void glEnableClientState_enc(void *self , GLenum array)
1916 {
1917
1918         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1919         IOStream *stream = ctx->m_stream;
1920         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1921         bool useChecksum = checksumCalculator->getVersion() > 0;
1922
1923          unsigned char *ptr;
1924          unsigned char *buf;
1925          const size_t sizeWithoutChecksum = 8 + 4;
1926          const size_t checksumSize = checksumCalculator->checksumByteSize();
1927          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1928         buf = stream->alloc(totalSize);
1929         ptr = buf;
1930         int tmp = OP_glEnableClientState;memcpy(ptr, &tmp, 4); ptr += 4;
1931         memcpy(ptr, &totalSize, 4);  ptr += 4;
1932
1933                 memcpy(ptr, &array, 4); ptr += 4;
1934
1935         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1936         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1937
1938 }
1939
1940 void glFinish_enc(void *self )
1941 {
1942
1943         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1944         IOStream *stream = ctx->m_stream;
1945         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1946         bool useChecksum = checksumCalculator->getVersion() > 0;
1947
1948          unsigned char *ptr;
1949          unsigned char *buf;
1950          const size_t sizeWithoutChecksum = 8;
1951          const size_t checksumSize = checksumCalculator->checksumByteSize();
1952          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1953         buf = stream->alloc(totalSize);
1954         ptr = buf;
1955         int tmp = OP_glFinish;memcpy(ptr, &tmp, 4); ptr += 4;
1956         memcpy(ptr, &totalSize, 4);  ptr += 4;
1957
1958
1959         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1960         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1961
1962 }
1963
1964 void glFlush_enc(void *self )
1965 {
1966
1967         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1968         IOStream *stream = ctx->m_stream;
1969         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1970         bool useChecksum = checksumCalculator->getVersion() > 0;
1971
1972          unsigned char *ptr;
1973          unsigned char *buf;
1974          const size_t sizeWithoutChecksum = 8;
1975          const size_t checksumSize = checksumCalculator->checksumByteSize();
1976          const size_t totalSize = sizeWithoutChecksum + checksumSize;
1977         buf = stream->alloc(totalSize);
1978         ptr = buf;
1979         int tmp = OP_glFlush;memcpy(ptr, &tmp, 4); ptr += 4;
1980         memcpy(ptr, &totalSize, 4);  ptr += 4;
1981
1982
1983         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
1984         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
1985
1986 }
1987
1988 void glFogx_enc(void *self , GLenum pname, GLfixed param)
1989 {
1990
1991         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
1992         IOStream *stream = ctx->m_stream;
1993         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
1994         bool useChecksum = checksumCalculator->getVersion() > 0;
1995
1996          unsigned char *ptr;
1997          unsigned char *buf;
1998          const size_t sizeWithoutChecksum = 8 + 4 + 4;
1999          const size_t checksumSize = checksumCalculator->checksumByteSize();
2000          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2001         buf = stream->alloc(totalSize);
2002         ptr = buf;
2003         int tmp = OP_glFogx;memcpy(ptr, &tmp, 4); ptr += 4;
2004         memcpy(ptr, &totalSize, 4);  ptr += 4;
2005
2006                 memcpy(ptr, &pname, 4); ptr += 4;
2007                 memcpy(ptr, &param, 4); ptr += 4;
2008
2009         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2010         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2011
2012 }
2013
2014 void glFogxv_enc(void *self , GLenum pname, const GLfixed* params)
2015 {
2016
2017         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2018         IOStream *stream = ctx->m_stream;
2019         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2020         bool useChecksum = checksumCalculator->getVersion() > 0;
2021
2022         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
2023          unsigned char *ptr;
2024          unsigned char *buf;
2025          const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4;
2026          const size_t checksumSize = checksumCalculator->checksumByteSize();
2027          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2028         buf = stream->alloc(totalSize);
2029         ptr = buf;
2030         int tmp = OP_glFogxv;memcpy(ptr, &tmp, 4); ptr += 4;
2031         memcpy(ptr, &totalSize, 4);  ptr += 4;
2032
2033                 memcpy(ptr, &pname, 4); ptr += 4;
2034         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2035         memcpy(ptr, params, __size_params);ptr += __size_params;
2036
2037         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2038         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2039
2040 }
2041
2042 void glFrontFace_enc(void *self , GLenum mode)
2043 {
2044
2045         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2046         IOStream *stream = ctx->m_stream;
2047         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2048         bool useChecksum = checksumCalculator->getVersion() > 0;
2049
2050          unsigned char *ptr;
2051          unsigned char *buf;
2052          const size_t sizeWithoutChecksum = 8 + 4;
2053          const size_t checksumSize = checksumCalculator->checksumByteSize();
2054          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2055         buf = stream->alloc(totalSize);
2056         ptr = buf;
2057         int tmp = OP_glFrontFace;memcpy(ptr, &tmp, 4); ptr += 4;
2058         memcpy(ptr, &totalSize, 4);  ptr += 4;
2059
2060                 memcpy(ptr, &mode, 4); ptr += 4;
2061
2062         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2063         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2064
2065 }
2066
2067 void glFrustumx_enc(void *self , GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
2068 {
2069
2070         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2071         IOStream *stream = ctx->m_stream;
2072         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2073         bool useChecksum = checksumCalculator->getVersion() > 0;
2074
2075          unsigned char *ptr;
2076          unsigned char *buf;
2077          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4;
2078          const size_t checksumSize = checksumCalculator->checksumByteSize();
2079          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2080         buf = stream->alloc(totalSize);
2081         ptr = buf;
2082         int tmp = OP_glFrustumx;memcpy(ptr, &tmp, 4); ptr += 4;
2083         memcpy(ptr, &totalSize, 4);  ptr += 4;
2084
2085                 memcpy(ptr, &left, 4); ptr += 4;
2086                 memcpy(ptr, &right, 4); ptr += 4;
2087                 memcpy(ptr, &bottom, 4); ptr += 4;
2088                 memcpy(ptr, &top, 4); ptr += 4;
2089                 memcpy(ptr, &zNear, 4); ptr += 4;
2090                 memcpy(ptr, &zFar, 4); ptr += 4;
2091
2092         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2093         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2094
2095 }
2096
2097 void glGetBooleanv_enc(void *self , GLenum pname, GLboolean* params)
2098 {
2099
2100         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2101         IOStream *stream = ctx->m_stream;
2102         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2103         bool useChecksum = checksumCalculator->getVersion() > 0;
2104
2105         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLboolean));
2106          unsigned char *ptr;
2107          unsigned char *buf;
2108          const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4;
2109          const size_t checksumSize = checksumCalculator->checksumByteSize();
2110          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2111         buf = stream->alloc(totalSize);
2112         ptr = buf;
2113         int tmp = OP_glGetBooleanv;memcpy(ptr, &tmp, 4); ptr += 4;
2114         memcpy(ptr, &totalSize, 4);  ptr += 4;
2115
2116                 memcpy(ptr, &pname, 4); ptr += 4;
2117         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2118
2119         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2120         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2121
2122         stream->readback(params, __size_params);
2123         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
2124         if (useChecksum) {
2125                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
2126                 stream->readback(checksumBuf.get(), checksumSize);
2127                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
2128                         ALOGE("glGetBooleanv: GL communication error, please report this issue to b.android.com.\n");
2129                         abort();
2130                 }
2131         }
2132 }
2133
2134 void glGetBufferParameteriv_enc(void *self , GLenum target, GLenum pname, GLint* params)
2135 {
2136
2137         gl_encoder_context_t *ctx = (gl_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 + __size_params + 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_glGetBufferParameteriv;memcpy(ptr, &tmp, 4); ptr += 4;
2151         memcpy(ptr, &totalSize, 4);  ptr += 4;
2152
2153                 memcpy(ptr, &target, 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                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
2164                 stream->readback(checksumBuf.get(), checksumSize);
2165                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
2166                         ALOGE("glGetBufferParameteriv: GL communication error, please report this issue to b.android.com.\n");
2167                         abort();
2168                 }
2169         }
2170 }
2171
2172 void glClipPlanex_enc(void *self , GLenum pname, const GLfixed* eqn)
2173 {
2174
2175         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2176         IOStream *stream = ctx->m_stream;
2177         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2178         bool useChecksum = checksumCalculator->getVersion() > 0;
2179
2180         const unsigned int __size_eqn =  (4 * sizeof(GLfixed));
2181          unsigned char *ptr;
2182          unsigned char *buf;
2183          const size_t sizeWithoutChecksum = 8 + 4 + __size_eqn + 1*4;
2184          const size_t checksumSize = checksumCalculator->checksumByteSize();
2185          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2186         buf = stream->alloc(totalSize);
2187         ptr = buf;
2188         int tmp = OP_glClipPlanex;memcpy(ptr, &tmp, 4); ptr += 4;
2189         memcpy(ptr, &totalSize, 4);  ptr += 4;
2190
2191                 memcpy(ptr, &pname, 4); ptr += 4;
2192         *(unsigned int *)(ptr) = __size_eqn; ptr += 4;
2193         memcpy(ptr, eqn, __size_eqn);ptr += __size_eqn;
2194
2195         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2196         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2197
2198 }
2199
2200 void glGenBuffers_enc(void *self , GLsizei n, GLuint* buffers)
2201 {
2202
2203         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2204         IOStream *stream = ctx->m_stream;
2205         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2206         bool useChecksum = checksumCalculator->getVersion() > 0;
2207
2208         const unsigned int __size_buffers =  (n * sizeof(GLuint));
2209          unsigned char *ptr;
2210          unsigned char *buf;
2211          const size_t sizeWithoutChecksum = 8 + 4 + __size_buffers + 1*4;
2212          const size_t checksumSize = checksumCalculator->checksumByteSize();
2213          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2214         buf = stream->alloc(totalSize);
2215         ptr = buf;
2216         int tmp = OP_glGenBuffers;memcpy(ptr, &tmp, 4); ptr += 4;
2217         memcpy(ptr, &totalSize, 4);  ptr += 4;
2218
2219                 memcpy(ptr, &n, 4); ptr += 4;
2220         *(unsigned int *)(ptr) = __size_buffers; ptr += 4;
2221
2222         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2223         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2224
2225         stream->readback(buffers, __size_buffers);
2226         if (useChecksum) checksumCalculator->addBuffer(buffers, __size_buffers);
2227         if (useChecksum) {
2228                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
2229                 stream->readback(checksumBuf.get(), checksumSize);
2230                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
2231                         ALOGE("glGenBuffers: GL communication error, please report this issue to b.android.com.\n");
2232                         abort();
2233                 }
2234         }
2235 }
2236
2237 void glGenTextures_enc(void *self , GLsizei n, GLuint* textures)
2238 {
2239
2240         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2241         IOStream *stream = ctx->m_stream;
2242         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2243         bool useChecksum = checksumCalculator->getVersion() > 0;
2244
2245         const unsigned int __size_textures =  (n * sizeof(GLuint));
2246          unsigned char *ptr;
2247          unsigned char *buf;
2248          const size_t sizeWithoutChecksum = 8 + 4 + __size_textures + 1*4;
2249          const size_t checksumSize = checksumCalculator->checksumByteSize();
2250          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2251         buf = stream->alloc(totalSize);
2252         ptr = buf;
2253         int tmp = OP_glGenTextures;memcpy(ptr, &tmp, 4); ptr += 4;
2254         memcpy(ptr, &totalSize, 4);  ptr += 4;
2255
2256                 memcpy(ptr, &n, 4); ptr += 4;
2257         *(unsigned int *)(ptr) = __size_textures; ptr += 4;
2258
2259         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2260         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2261
2262         stream->readback(textures, __size_textures);
2263         if (useChecksum) checksumCalculator->addBuffer(textures, __size_textures);
2264         if (useChecksum) {
2265                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
2266                 stream->readback(checksumBuf.get(), checksumSize);
2267                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
2268                         ALOGE("glGenTextures: GL communication error, please report this issue to b.android.com.\n");
2269                         abort();
2270                 }
2271         }
2272 }
2273
2274 GLenum glGetError_enc(void *self )
2275 {
2276
2277         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2278         IOStream *stream = ctx->m_stream;
2279         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2280         bool useChecksum = checksumCalculator->getVersion() > 0;
2281
2282          unsigned char *ptr;
2283          unsigned char *buf;
2284          const size_t sizeWithoutChecksum = 8;
2285          const size_t checksumSize = checksumCalculator->checksumByteSize();
2286          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2287         buf = stream->alloc(totalSize);
2288         ptr = buf;
2289         int tmp = OP_glGetError;memcpy(ptr, &tmp, 4); ptr += 4;
2290         memcpy(ptr, &totalSize, 4);  ptr += 4;
2291
2292
2293         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2294         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2295
2296
2297         GLenum retval;
2298         stream->readback(&retval, 4);
2299         if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
2300         if (useChecksum) {
2301                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
2302                 stream->readback(checksumBuf.get(), checksumSize);
2303                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
2304                         ALOGE("glGetError: GL communication error, please report this issue to b.android.com.\n");
2305                         abort();
2306                 }
2307         }
2308         return retval;
2309 }
2310
2311 void glGetFixedv_enc(void *self , GLenum pname, GLfixed* params)
2312 {
2313
2314         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2315         IOStream *stream = ctx->m_stream;
2316         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2317         bool useChecksum = checksumCalculator->getVersion() > 0;
2318
2319         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
2320          unsigned char *ptr;
2321          unsigned char *buf;
2322          const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4;
2323          const size_t checksumSize = checksumCalculator->checksumByteSize();
2324          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2325         buf = stream->alloc(totalSize);
2326         ptr = buf;
2327         int tmp = OP_glGetFixedv;memcpy(ptr, &tmp, 4); ptr += 4;
2328         memcpy(ptr, &totalSize, 4);  ptr += 4;
2329
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                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
2340                 stream->readback(checksumBuf.get(), checksumSize);
2341                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
2342                         ALOGE("glGetFixedv: GL communication error, please report this issue to b.android.com.\n");
2343                         abort();
2344                 }
2345         }
2346 }
2347
2348 void glGetIntegerv_enc(void *self , GLenum pname, GLint* params)
2349 {
2350
2351         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2352         IOStream *stream = ctx->m_stream;
2353         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2354         bool useChecksum = checksumCalculator->getVersion() > 0;
2355
2356         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
2357          unsigned char *ptr;
2358          unsigned char *buf;
2359          const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4;
2360          const size_t checksumSize = checksumCalculator->checksumByteSize();
2361          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2362         buf = stream->alloc(totalSize);
2363         ptr = buf;
2364         int tmp = OP_glGetIntegerv;memcpy(ptr, &tmp, 4); ptr += 4;
2365         memcpy(ptr, &totalSize, 4);  ptr += 4;
2366
2367                 memcpy(ptr, &pname, 4); ptr += 4;
2368         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2369
2370         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2371         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2372
2373         stream->readback(params, __size_params);
2374         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
2375         if (useChecksum) {
2376                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
2377                 stream->readback(checksumBuf.get(), checksumSize);
2378                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
2379                         ALOGE("glGetIntegerv: GL communication error, please report this issue to b.android.com.\n");
2380                         abort();
2381                 }
2382         }
2383 }
2384
2385 void glGetLightxv_enc(void *self , GLenum light, GLenum pname, GLfixed* params)
2386 {
2387
2388         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2389         IOStream *stream = ctx->m_stream;
2390         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2391         bool useChecksum = checksumCalculator->getVersion() > 0;
2392
2393         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
2394          unsigned char *ptr;
2395          unsigned char *buf;
2396          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
2397          const size_t checksumSize = checksumCalculator->checksumByteSize();
2398          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2399         buf = stream->alloc(totalSize);
2400         ptr = buf;
2401         int tmp = OP_glGetLightxv;memcpy(ptr, &tmp, 4); ptr += 4;
2402         memcpy(ptr, &totalSize, 4);  ptr += 4;
2403
2404                 memcpy(ptr, &light, 4); ptr += 4;
2405                 memcpy(ptr, &pname, 4); ptr += 4;
2406         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2407
2408         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2409         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2410
2411         stream->readback(params, __size_params);
2412         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
2413         if (useChecksum) {
2414                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
2415                 stream->readback(checksumBuf.get(), checksumSize);
2416                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
2417                         ALOGE("glGetLightxv: GL communication error, please report this issue to b.android.com.\n");
2418                         abort();
2419                 }
2420         }
2421 }
2422
2423 void glGetMaterialxv_enc(void *self , GLenum face, GLenum pname, GLfixed* params)
2424 {
2425
2426         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2427         IOStream *stream = ctx->m_stream;
2428         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2429         bool useChecksum = checksumCalculator->getVersion() > 0;
2430
2431         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
2432          unsigned char *ptr;
2433          unsigned char *buf;
2434          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
2435          const size_t checksumSize = checksumCalculator->checksumByteSize();
2436          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2437         buf = stream->alloc(totalSize);
2438         ptr = buf;
2439         int tmp = OP_glGetMaterialxv;memcpy(ptr, &tmp, 4); ptr += 4;
2440         memcpy(ptr, &totalSize, 4);  ptr += 4;
2441
2442                 memcpy(ptr, &face, 4); ptr += 4;
2443                 memcpy(ptr, &pname, 4); ptr += 4;
2444         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2445
2446         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2447         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2448
2449         stream->readback(params, __size_params);
2450         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
2451         if (useChecksum) {
2452                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
2453                 stream->readback(checksumBuf.get(), checksumSize);
2454                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
2455                         ALOGE("glGetMaterialxv: GL communication error, please report this issue to b.android.com.\n");
2456                         abort();
2457                 }
2458         }
2459 }
2460
2461 void glGetTexEnviv_enc(void *self , GLenum env, GLenum pname, GLint* params)
2462 {
2463
2464         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2465         IOStream *stream = ctx->m_stream;
2466         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2467         bool useChecksum = checksumCalculator->getVersion() > 0;
2468
2469         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
2470          unsigned char *ptr;
2471          unsigned char *buf;
2472          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
2473          const size_t checksumSize = checksumCalculator->checksumByteSize();
2474          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2475         buf = stream->alloc(totalSize);
2476         ptr = buf;
2477         int tmp = OP_glGetTexEnviv;memcpy(ptr, &tmp, 4); ptr += 4;
2478         memcpy(ptr, &totalSize, 4);  ptr += 4;
2479
2480                 memcpy(ptr, &env, 4); ptr += 4;
2481                 memcpy(ptr, &pname, 4); ptr += 4;
2482         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2483
2484         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2485         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2486
2487         stream->readback(params, __size_params);
2488         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
2489         if (useChecksum) {
2490                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
2491                 stream->readback(checksumBuf.get(), checksumSize);
2492                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
2493                         ALOGE("glGetTexEnviv: GL communication error, please report this issue to b.android.com.\n");
2494                         abort();
2495                 }
2496         }
2497 }
2498
2499 void glGetTexEnvxv_enc(void *self , GLenum env, GLenum pname, GLfixed* params)
2500 {
2501
2502         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2503         IOStream *stream = ctx->m_stream;
2504         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2505         bool useChecksum = checksumCalculator->getVersion() > 0;
2506
2507         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
2508          unsigned char *ptr;
2509          unsigned char *buf;
2510          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
2511          const size_t checksumSize = checksumCalculator->checksumByteSize();
2512          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2513         buf = stream->alloc(totalSize);
2514         ptr = buf;
2515         int tmp = OP_glGetTexEnvxv;memcpy(ptr, &tmp, 4); ptr += 4;
2516         memcpy(ptr, &totalSize, 4);  ptr += 4;
2517
2518                 memcpy(ptr, &env, 4); ptr += 4;
2519                 memcpy(ptr, &pname, 4); ptr += 4;
2520         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2521
2522         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2523         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2524
2525         stream->readback(params, __size_params);
2526         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
2527         if (useChecksum) {
2528                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
2529                 stream->readback(checksumBuf.get(), checksumSize);
2530                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
2531                         ALOGE("glGetTexEnvxv: GL communication error, please report this issue to b.android.com.\n");
2532                         abort();
2533                 }
2534         }
2535 }
2536
2537 void glGetTexParameteriv_enc(void *self , GLenum target, GLenum pname, GLint* params)
2538 {
2539
2540         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2541         IOStream *stream = ctx->m_stream;
2542         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2543         bool useChecksum = checksumCalculator->getVersion() > 0;
2544
2545         const unsigned int __size_params =  (sizeof(GLint));
2546          unsigned char *ptr;
2547          unsigned char *buf;
2548          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
2549          const size_t checksumSize = checksumCalculator->checksumByteSize();
2550          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2551         buf = stream->alloc(totalSize);
2552         ptr = buf;
2553         int tmp = OP_glGetTexParameteriv;memcpy(ptr, &tmp, 4); ptr += 4;
2554         memcpy(ptr, &totalSize, 4);  ptr += 4;
2555
2556                 memcpy(ptr, &target, 4); ptr += 4;
2557                 memcpy(ptr, &pname, 4); ptr += 4;
2558         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2559
2560         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2561         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2562
2563         stream->readback(params, __size_params);
2564         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
2565         if (useChecksum) {
2566                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
2567                 stream->readback(checksumBuf.get(), checksumSize);
2568                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
2569                         ALOGE("glGetTexParameteriv: GL communication error, please report this issue to b.android.com.\n");
2570                         abort();
2571                 }
2572         }
2573 }
2574
2575 void glGetTexParameterxv_enc(void *self , GLenum target, GLenum pname, GLfixed* params)
2576 {
2577
2578         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2579         IOStream *stream = ctx->m_stream;
2580         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2581         bool useChecksum = checksumCalculator->getVersion() > 0;
2582
2583         const unsigned int __size_params =  (sizeof(GLfixed));
2584          unsigned char *ptr;
2585          unsigned char *buf;
2586          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
2587          const size_t checksumSize = checksumCalculator->checksumByteSize();
2588          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2589         buf = stream->alloc(totalSize);
2590         ptr = buf;
2591         int tmp = OP_glGetTexParameterxv;memcpy(ptr, &tmp, 4); ptr += 4;
2592         memcpy(ptr, &totalSize, 4);  ptr += 4;
2593
2594                 memcpy(ptr, &target, 4); ptr += 4;
2595                 memcpy(ptr, &pname, 4); ptr += 4;
2596         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2597
2598         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2599         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2600
2601         stream->readback(params, __size_params);
2602         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
2603         if (useChecksum) {
2604                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
2605                 stream->readback(checksumBuf.get(), checksumSize);
2606                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
2607                         ALOGE("glGetTexParameterxv: GL communication error, please report this issue to b.android.com.\n");
2608                         abort();
2609                 }
2610         }
2611 }
2612
2613 void glHint_enc(void *self , GLenum target, GLenum mode)
2614 {
2615
2616         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2617         IOStream *stream = ctx->m_stream;
2618         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2619         bool useChecksum = checksumCalculator->getVersion() > 0;
2620
2621          unsigned char *ptr;
2622          unsigned char *buf;
2623          const size_t sizeWithoutChecksum = 8 + 4 + 4;
2624          const size_t checksumSize = checksumCalculator->checksumByteSize();
2625          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2626         buf = stream->alloc(totalSize);
2627         ptr = buf;
2628         int tmp = OP_glHint;memcpy(ptr, &tmp, 4); ptr += 4;
2629         memcpy(ptr, &totalSize, 4);  ptr += 4;
2630
2631                 memcpy(ptr, &target, 4); ptr += 4;
2632                 memcpy(ptr, &mode, 4); ptr += 4;
2633
2634         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2635         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2636
2637 }
2638
2639 GLboolean glIsBuffer_enc(void *self , GLuint buffer)
2640 {
2641
2642         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2643         IOStream *stream = ctx->m_stream;
2644         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2645         bool useChecksum = checksumCalculator->getVersion() > 0;
2646
2647          unsigned char *ptr;
2648          unsigned char *buf;
2649          const size_t sizeWithoutChecksum = 8 + 4;
2650          const size_t checksumSize = checksumCalculator->checksumByteSize();
2651          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2652         buf = stream->alloc(totalSize);
2653         ptr = buf;
2654         int tmp = OP_glIsBuffer;memcpy(ptr, &tmp, 4); ptr += 4;
2655         memcpy(ptr, &totalSize, 4);  ptr += 4;
2656
2657                 memcpy(ptr, &buffer, 4); ptr += 4;
2658
2659         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2660         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2661
2662
2663         GLboolean retval;
2664         stream->readback(&retval, 1);
2665         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
2666         if (useChecksum) {
2667                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
2668                 stream->readback(checksumBuf.get(), checksumSize);
2669                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
2670                         ALOGE("glIsBuffer: GL communication error, please report this issue to b.android.com.\n");
2671                         abort();
2672                 }
2673         }
2674         return retval;
2675 }
2676
2677 GLboolean glIsEnabled_enc(void *self , GLenum cap)
2678 {
2679
2680         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2681         IOStream *stream = ctx->m_stream;
2682         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2683         bool useChecksum = checksumCalculator->getVersion() > 0;
2684
2685          unsigned char *ptr;
2686          unsigned char *buf;
2687          const size_t sizeWithoutChecksum = 8 + 4;
2688          const size_t checksumSize = checksumCalculator->checksumByteSize();
2689          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2690         buf = stream->alloc(totalSize);
2691         ptr = buf;
2692         int tmp = OP_glIsEnabled;memcpy(ptr, &tmp, 4); ptr += 4;
2693         memcpy(ptr, &totalSize, 4);  ptr += 4;
2694
2695                 memcpy(ptr, &cap, 4); ptr += 4;
2696
2697         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2698         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2699
2700
2701         GLboolean retval;
2702         stream->readback(&retval, 1);
2703         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
2704         if (useChecksum) {
2705                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
2706                 stream->readback(checksumBuf.get(), checksumSize);
2707                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
2708                         ALOGE("glIsEnabled: GL communication error, please report this issue to b.android.com.\n");
2709                         abort();
2710                 }
2711         }
2712         return retval;
2713 }
2714
2715 GLboolean glIsTexture_enc(void *self , GLuint texture)
2716 {
2717
2718         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2719         IOStream *stream = ctx->m_stream;
2720         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2721         bool useChecksum = checksumCalculator->getVersion() > 0;
2722
2723          unsigned char *ptr;
2724          unsigned char *buf;
2725          const size_t sizeWithoutChecksum = 8 + 4;
2726          const size_t checksumSize = checksumCalculator->checksumByteSize();
2727          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2728         buf = stream->alloc(totalSize);
2729         ptr = buf;
2730         int tmp = OP_glIsTexture;memcpy(ptr, &tmp, 4); ptr += 4;
2731         memcpy(ptr, &totalSize, 4);  ptr += 4;
2732
2733                 memcpy(ptr, &texture, 4); ptr += 4;
2734
2735         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2736         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2737
2738
2739         GLboolean retval;
2740         stream->readback(&retval, 1);
2741         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
2742         if (useChecksum) {
2743                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
2744                 stream->readback(checksumBuf.get(), checksumSize);
2745                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
2746                         ALOGE("glIsTexture: GL communication error, please report this issue to b.android.com.\n");
2747                         abort();
2748                 }
2749         }
2750         return retval;
2751 }
2752
2753 void glLightModelx_enc(void *self , GLenum pname, GLfixed param)
2754 {
2755
2756         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2757         IOStream *stream = ctx->m_stream;
2758         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2759         bool useChecksum = checksumCalculator->getVersion() > 0;
2760
2761          unsigned char *ptr;
2762          unsigned char *buf;
2763          const size_t sizeWithoutChecksum = 8 + 4 + 4;
2764          const size_t checksumSize = checksumCalculator->checksumByteSize();
2765          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2766         buf = stream->alloc(totalSize);
2767         ptr = buf;
2768         int tmp = OP_glLightModelx;memcpy(ptr, &tmp, 4); ptr += 4;
2769         memcpy(ptr, &totalSize, 4);  ptr += 4;
2770
2771                 memcpy(ptr, &pname, 4); ptr += 4;
2772                 memcpy(ptr, &param, 4); ptr += 4;
2773
2774         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2775         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2776
2777 }
2778
2779 void glLightModelxv_enc(void *self , GLenum pname, const GLfixed* params)
2780 {
2781
2782         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2783         IOStream *stream = ctx->m_stream;
2784         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2785         bool useChecksum = checksumCalculator->getVersion() > 0;
2786
2787         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
2788          unsigned char *ptr;
2789          unsigned char *buf;
2790          const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4;
2791          const size_t checksumSize = checksumCalculator->checksumByteSize();
2792          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2793         buf = stream->alloc(totalSize);
2794         ptr = buf;
2795         int tmp = OP_glLightModelxv;memcpy(ptr, &tmp, 4); ptr += 4;
2796         memcpy(ptr, &totalSize, 4);  ptr += 4;
2797
2798                 memcpy(ptr, &pname, 4); ptr += 4;
2799         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2800         memcpy(ptr, params, __size_params);ptr += __size_params;
2801
2802         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2803         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2804
2805 }
2806
2807 void glLightx_enc(void *self , GLenum light, GLenum pname, GLfixed param)
2808 {
2809
2810         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2811         IOStream *stream = ctx->m_stream;
2812         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2813         bool useChecksum = checksumCalculator->getVersion() > 0;
2814
2815          unsigned char *ptr;
2816          unsigned char *buf;
2817          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
2818          const size_t checksumSize = checksumCalculator->checksumByteSize();
2819          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2820         buf = stream->alloc(totalSize);
2821         ptr = buf;
2822         int tmp = OP_glLightx;memcpy(ptr, &tmp, 4); ptr += 4;
2823         memcpy(ptr, &totalSize, 4);  ptr += 4;
2824
2825                 memcpy(ptr, &light, 4); ptr += 4;
2826                 memcpy(ptr, &pname, 4); ptr += 4;
2827                 memcpy(ptr, &param, 4); ptr += 4;
2828
2829         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2830         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2831
2832 }
2833
2834 void glLightxv_enc(void *self , GLenum light, GLenum pname, const GLfixed* params)
2835 {
2836
2837         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2838         IOStream *stream = ctx->m_stream;
2839         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2840         bool useChecksum = checksumCalculator->getVersion() > 0;
2841
2842         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
2843          unsigned char *ptr;
2844          unsigned char *buf;
2845          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
2846          const size_t checksumSize = checksumCalculator->checksumByteSize();
2847          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2848         buf = stream->alloc(totalSize);
2849         ptr = buf;
2850         int tmp = OP_glLightxv;memcpy(ptr, &tmp, 4); ptr += 4;
2851         memcpy(ptr, &totalSize, 4);  ptr += 4;
2852
2853                 memcpy(ptr, &light, 4); ptr += 4;
2854                 memcpy(ptr, &pname, 4); ptr += 4;
2855         *(unsigned int *)(ptr) = __size_params; ptr += 4;
2856         memcpy(ptr, params, __size_params);ptr += __size_params;
2857
2858         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2859         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2860
2861 }
2862
2863 void glLineWidthx_enc(void *self , GLfixed width)
2864 {
2865
2866         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2867         IOStream *stream = ctx->m_stream;
2868         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2869         bool useChecksum = checksumCalculator->getVersion() > 0;
2870
2871          unsigned char *ptr;
2872          unsigned char *buf;
2873          const size_t sizeWithoutChecksum = 8 + 4;
2874          const size_t checksumSize = checksumCalculator->checksumByteSize();
2875          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2876         buf = stream->alloc(totalSize);
2877         ptr = buf;
2878         int tmp = OP_glLineWidthx;memcpy(ptr, &tmp, 4); ptr += 4;
2879         memcpy(ptr, &totalSize, 4);  ptr += 4;
2880
2881                 memcpy(ptr, &width, 4); ptr += 4;
2882
2883         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2884         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2885
2886 }
2887
2888 void glLoadIdentity_enc(void *self )
2889 {
2890
2891         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2892         IOStream *stream = ctx->m_stream;
2893         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2894         bool useChecksum = checksumCalculator->getVersion() > 0;
2895
2896          unsigned char *ptr;
2897          unsigned char *buf;
2898          const size_t sizeWithoutChecksum = 8;
2899          const size_t checksumSize = checksumCalculator->checksumByteSize();
2900          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2901         buf = stream->alloc(totalSize);
2902         ptr = buf;
2903         int tmp = OP_glLoadIdentity;memcpy(ptr, &tmp, 4); ptr += 4;
2904         memcpy(ptr, &totalSize, 4);  ptr += 4;
2905
2906
2907         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2908         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2909
2910 }
2911
2912 void glLoadMatrixx_enc(void *self , const GLfixed* m)
2913 {
2914
2915         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2916         IOStream *stream = ctx->m_stream;
2917         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2918         bool useChecksum = checksumCalculator->getVersion() > 0;
2919
2920         const unsigned int __size_m =  (16 * sizeof(GLfixed));
2921          unsigned char *ptr;
2922          unsigned char *buf;
2923          const size_t sizeWithoutChecksum = 8 + __size_m + 1*4;
2924          const size_t checksumSize = checksumCalculator->checksumByteSize();
2925          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2926         buf = stream->alloc(totalSize);
2927         ptr = buf;
2928         int tmp = OP_glLoadMatrixx;memcpy(ptr, &tmp, 4); ptr += 4;
2929         memcpy(ptr, &totalSize, 4);  ptr += 4;
2930
2931         *(unsigned int *)(ptr) = __size_m; ptr += 4;
2932         memcpy(ptr, m, __size_m);ptr += __size_m;
2933
2934         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2935         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2936
2937 }
2938
2939 void glLogicOp_enc(void *self , GLenum opcode)
2940 {
2941
2942         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2943         IOStream *stream = ctx->m_stream;
2944         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2945         bool useChecksum = checksumCalculator->getVersion() > 0;
2946
2947          unsigned char *ptr;
2948          unsigned char *buf;
2949          const size_t sizeWithoutChecksum = 8 + 4;
2950          const size_t checksumSize = checksumCalculator->checksumByteSize();
2951          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2952         buf = stream->alloc(totalSize);
2953         ptr = buf;
2954         int tmp = OP_glLogicOp;memcpy(ptr, &tmp, 4); ptr += 4;
2955         memcpy(ptr, &totalSize, 4);  ptr += 4;
2956
2957                 memcpy(ptr, &opcode, 4); ptr += 4;
2958
2959         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2960         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2961
2962 }
2963
2964 void glMaterialx_enc(void *self , GLenum face, GLenum pname, GLfixed param)
2965 {
2966
2967         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2968         IOStream *stream = ctx->m_stream;
2969         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2970         bool useChecksum = checksumCalculator->getVersion() > 0;
2971
2972          unsigned char *ptr;
2973          unsigned char *buf;
2974          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
2975          const size_t checksumSize = checksumCalculator->checksumByteSize();
2976          const size_t totalSize = sizeWithoutChecksum + checksumSize;
2977         buf = stream->alloc(totalSize);
2978         ptr = buf;
2979         int tmp = OP_glMaterialx;memcpy(ptr, &tmp, 4); ptr += 4;
2980         memcpy(ptr, &totalSize, 4);  ptr += 4;
2981
2982                 memcpy(ptr, &face, 4); ptr += 4;
2983                 memcpy(ptr, &pname, 4); ptr += 4;
2984                 memcpy(ptr, &param, 4); ptr += 4;
2985
2986         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
2987         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
2988
2989 }
2990
2991 void glMaterialxv_enc(void *self , GLenum face, GLenum pname, const GLfixed* params)
2992 {
2993
2994         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
2995         IOStream *stream = ctx->m_stream;
2996         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
2997         bool useChecksum = checksumCalculator->getVersion() > 0;
2998
2999         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
3000          unsigned char *ptr;
3001          unsigned char *buf;
3002          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
3003          const size_t checksumSize = checksumCalculator->checksumByteSize();
3004          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3005         buf = stream->alloc(totalSize);
3006         ptr = buf;
3007         int tmp = OP_glMaterialxv;memcpy(ptr, &tmp, 4); ptr += 4;
3008         memcpy(ptr, &totalSize, 4);  ptr += 4;
3009
3010                 memcpy(ptr, &face, 4); ptr += 4;
3011                 memcpy(ptr, &pname, 4); ptr += 4;
3012         *(unsigned int *)(ptr) = __size_params; ptr += 4;
3013         memcpy(ptr, params, __size_params);ptr += __size_params;
3014
3015         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3016         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3017
3018 }
3019
3020 void glMatrixMode_enc(void *self , GLenum mode)
3021 {
3022
3023         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3024         IOStream *stream = ctx->m_stream;
3025         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3026         bool useChecksum = checksumCalculator->getVersion() > 0;
3027
3028          unsigned char *ptr;
3029          unsigned char *buf;
3030          const size_t sizeWithoutChecksum = 8 + 4;
3031          const size_t checksumSize = checksumCalculator->checksumByteSize();
3032          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3033         buf = stream->alloc(totalSize);
3034         ptr = buf;
3035         int tmp = OP_glMatrixMode;memcpy(ptr, &tmp, 4); ptr += 4;
3036         memcpy(ptr, &totalSize, 4);  ptr += 4;
3037
3038                 memcpy(ptr, &mode, 4); ptr += 4;
3039
3040         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3041         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3042
3043 }
3044
3045 void glMultMatrixx_enc(void *self , const GLfixed* m)
3046 {
3047
3048         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3049         IOStream *stream = ctx->m_stream;
3050         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3051         bool useChecksum = checksumCalculator->getVersion() > 0;
3052
3053         const unsigned int __size_m =  (16 * sizeof(GLfixed));
3054          unsigned char *ptr;
3055          unsigned char *buf;
3056          const size_t sizeWithoutChecksum = 8 + __size_m + 1*4;
3057          const size_t checksumSize = checksumCalculator->checksumByteSize();
3058          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3059         buf = stream->alloc(totalSize);
3060         ptr = buf;
3061         int tmp = OP_glMultMatrixx;memcpy(ptr, &tmp, 4); ptr += 4;
3062         memcpy(ptr, &totalSize, 4);  ptr += 4;
3063
3064         *(unsigned int *)(ptr) = __size_m; ptr += 4;
3065         memcpy(ptr, m, __size_m);ptr += __size_m;
3066
3067         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3068         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3069
3070 }
3071
3072 void glMultiTexCoord4x_enc(void *self , GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
3073 {
3074
3075         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3076         IOStream *stream = ctx->m_stream;
3077         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3078         bool useChecksum = checksumCalculator->getVersion() > 0;
3079
3080          unsigned char *ptr;
3081          unsigned char *buf;
3082          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
3083          const size_t checksumSize = checksumCalculator->checksumByteSize();
3084          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3085         buf = stream->alloc(totalSize);
3086         ptr = buf;
3087         int tmp = OP_glMultiTexCoord4x;memcpy(ptr, &tmp, 4); ptr += 4;
3088         memcpy(ptr, &totalSize, 4);  ptr += 4;
3089
3090                 memcpy(ptr, &target, 4); ptr += 4;
3091                 memcpy(ptr, &s, 4); ptr += 4;
3092                 memcpy(ptr, &t, 4); ptr += 4;
3093                 memcpy(ptr, &r, 4); ptr += 4;
3094                 memcpy(ptr, &q, 4); ptr += 4;
3095
3096         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3097         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3098
3099 }
3100
3101 void glNormal3x_enc(void *self , GLfixed nx, GLfixed ny, GLfixed nz)
3102 {
3103
3104         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3105         IOStream *stream = ctx->m_stream;
3106         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3107         bool useChecksum = checksumCalculator->getVersion() > 0;
3108
3109          unsigned char *ptr;
3110          unsigned char *buf;
3111          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
3112          const size_t checksumSize = checksumCalculator->checksumByteSize();
3113          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3114         buf = stream->alloc(totalSize);
3115         ptr = buf;
3116         int tmp = OP_glNormal3x;memcpy(ptr, &tmp, 4); ptr += 4;
3117         memcpy(ptr, &totalSize, 4);  ptr += 4;
3118
3119                 memcpy(ptr, &nx, 4); ptr += 4;
3120                 memcpy(ptr, &ny, 4); ptr += 4;
3121                 memcpy(ptr, &nz, 4); ptr += 4;
3122
3123         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3124         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3125
3126 }
3127
3128 void glOrthox_enc(void *self , GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
3129 {
3130
3131         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3132         IOStream *stream = ctx->m_stream;
3133         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3134         bool useChecksum = checksumCalculator->getVersion() > 0;
3135
3136          unsigned char *ptr;
3137          unsigned char *buf;
3138          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4;
3139          const size_t checksumSize = checksumCalculator->checksumByteSize();
3140          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3141         buf = stream->alloc(totalSize);
3142         ptr = buf;
3143         int tmp = OP_glOrthox;memcpy(ptr, &tmp, 4); ptr += 4;
3144         memcpy(ptr, &totalSize, 4);  ptr += 4;
3145
3146                 memcpy(ptr, &left, 4); ptr += 4;
3147                 memcpy(ptr, &right, 4); ptr += 4;
3148                 memcpy(ptr, &bottom, 4); ptr += 4;
3149                 memcpy(ptr, &top, 4); ptr += 4;
3150                 memcpy(ptr, &zNear, 4); ptr += 4;
3151                 memcpy(ptr, &zFar, 4); ptr += 4;
3152
3153         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3154         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3155
3156 }
3157
3158 void glPixelStorei_enc(void *self , GLenum pname, GLint param)
3159 {
3160
3161         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3162         IOStream *stream = ctx->m_stream;
3163         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3164         bool useChecksum = checksumCalculator->getVersion() > 0;
3165
3166          unsigned char *ptr;
3167          unsigned char *buf;
3168          const size_t sizeWithoutChecksum = 8 + 4 + 4;
3169          const size_t checksumSize = checksumCalculator->checksumByteSize();
3170          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3171         buf = stream->alloc(totalSize);
3172         ptr = buf;
3173         int tmp = OP_glPixelStorei;memcpy(ptr, &tmp, 4); ptr += 4;
3174         memcpy(ptr, &totalSize, 4);  ptr += 4;
3175
3176                 memcpy(ptr, &pname, 4); ptr += 4;
3177                 memcpy(ptr, &param, 4); ptr += 4;
3178
3179         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3180         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3181
3182 }
3183
3184 void glPointParameterx_enc(void *self , GLenum pname, GLfixed param)
3185 {
3186
3187         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3188         IOStream *stream = ctx->m_stream;
3189         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3190         bool useChecksum = checksumCalculator->getVersion() > 0;
3191
3192          unsigned char *ptr;
3193          unsigned char *buf;
3194          const size_t sizeWithoutChecksum = 8 + 4 + 4;
3195          const size_t checksumSize = checksumCalculator->checksumByteSize();
3196          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3197         buf = stream->alloc(totalSize);
3198         ptr = buf;
3199         int tmp = OP_glPointParameterx;memcpy(ptr, &tmp, 4); ptr += 4;
3200         memcpy(ptr, &totalSize, 4);  ptr += 4;
3201
3202                 memcpy(ptr, &pname, 4); ptr += 4;
3203                 memcpy(ptr, &param, 4); ptr += 4;
3204
3205         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3206         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3207
3208 }
3209
3210 void glPointParameterxv_enc(void *self , GLenum pname, const GLfixed* params)
3211 {
3212
3213         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3214         IOStream *stream = ctx->m_stream;
3215         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3216         bool useChecksum = checksumCalculator->getVersion() > 0;
3217
3218         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
3219          unsigned char *ptr;
3220          unsigned char *buf;
3221          const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4;
3222          const size_t checksumSize = checksumCalculator->checksumByteSize();
3223          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3224         buf = stream->alloc(totalSize);
3225         ptr = buf;
3226         int tmp = OP_glPointParameterxv;memcpy(ptr, &tmp, 4); ptr += 4;
3227         memcpy(ptr, &totalSize, 4);  ptr += 4;
3228
3229                 memcpy(ptr, &pname, 4); ptr += 4;
3230         *(unsigned int *)(ptr) = __size_params; ptr += 4;
3231         memcpy(ptr, params, __size_params);ptr += __size_params;
3232
3233         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3234         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3235
3236 }
3237
3238 void glPointSizex_enc(void *self , GLfixed size)
3239 {
3240
3241         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3242         IOStream *stream = ctx->m_stream;
3243         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3244         bool useChecksum = checksumCalculator->getVersion() > 0;
3245
3246          unsigned char *ptr;
3247          unsigned char *buf;
3248          const size_t sizeWithoutChecksum = 8 + 4;
3249          const size_t checksumSize = checksumCalculator->checksumByteSize();
3250          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3251         buf = stream->alloc(totalSize);
3252         ptr = buf;
3253         int tmp = OP_glPointSizex;memcpy(ptr, &tmp, 4); ptr += 4;
3254         memcpy(ptr, &totalSize, 4);  ptr += 4;
3255
3256                 memcpy(ptr, &size, 4); ptr += 4;
3257
3258         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3259         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3260
3261 }
3262
3263 void glPolygonOffsetx_enc(void *self , GLfixed factor, GLfixed units)
3264 {
3265
3266         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3267         IOStream *stream = ctx->m_stream;
3268         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3269         bool useChecksum = checksumCalculator->getVersion() > 0;
3270
3271          unsigned char *ptr;
3272          unsigned char *buf;
3273          const size_t sizeWithoutChecksum = 8 + 4 + 4;
3274          const size_t checksumSize = checksumCalculator->checksumByteSize();
3275          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3276         buf = stream->alloc(totalSize);
3277         ptr = buf;
3278         int tmp = OP_glPolygonOffsetx;memcpy(ptr, &tmp, 4); ptr += 4;
3279         memcpy(ptr, &totalSize, 4);  ptr += 4;
3280
3281                 memcpy(ptr, &factor, 4); ptr += 4;
3282                 memcpy(ptr, &units, 4); ptr += 4;
3283
3284         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3285         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3286
3287 }
3288
3289 void glPopMatrix_enc(void *self )
3290 {
3291
3292         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3293         IOStream *stream = ctx->m_stream;
3294         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3295         bool useChecksum = checksumCalculator->getVersion() > 0;
3296
3297          unsigned char *ptr;
3298          unsigned char *buf;
3299          const size_t sizeWithoutChecksum = 8;
3300          const size_t checksumSize = checksumCalculator->checksumByteSize();
3301          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3302         buf = stream->alloc(totalSize);
3303         ptr = buf;
3304         int tmp = OP_glPopMatrix;memcpy(ptr, &tmp, 4); ptr += 4;
3305         memcpy(ptr, &totalSize, 4);  ptr += 4;
3306
3307
3308         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3309         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3310
3311 }
3312
3313 void glPushMatrix_enc(void *self )
3314 {
3315
3316         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3317         IOStream *stream = ctx->m_stream;
3318         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3319         bool useChecksum = checksumCalculator->getVersion() > 0;
3320
3321          unsigned char *ptr;
3322          unsigned char *buf;
3323          const size_t sizeWithoutChecksum = 8;
3324          const size_t checksumSize = checksumCalculator->checksumByteSize();
3325          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3326         buf = stream->alloc(totalSize);
3327         ptr = buf;
3328         int tmp = OP_glPushMatrix;memcpy(ptr, &tmp, 4); ptr += 4;
3329         memcpy(ptr, &totalSize, 4);  ptr += 4;
3330
3331
3332         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3333         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3334
3335 }
3336
3337 void glReadPixels_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
3338 {
3339
3340         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3341         IOStream *stream = ctx->m_stream;
3342         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3343         bool useChecksum = checksumCalculator->getVersion() > 0;
3344
3345         const unsigned int __size_pixels =  glesv1_enc::pixelDataSize(self, width, height, format, type, 1);
3346          unsigned char *ptr;
3347          unsigned char *buf;
3348          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
3349          const size_t checksumSize = checksumCalculator->checksumByteSize();
3350          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3351         buf = stream->alloc(totalSize);
3352         ptr = buf;
3353         int tmp = OP_glReadPixels;memcpy(ptr, &tmp, 4); ptr += 4;
3354         memcpy(ptr, &totalSize, 4);  ptr += 4;
3355
3356                 memcpy(ptr, &x, 4); ptr += 4;
3357                 memcpy(ptr, &y, 4); ptr += 4;
3358                 memcpy(ptr, &width, 4); ptr += 4;
3359                 memcpy(ptr, &height, 4); ptr += 4;
3360                 memcpy(ptr, &format, 4); ptr += 4;
3361                 memcpy(ptr, &type, 4); ptr += 4;
3362         *(unsigned int *)(ptr) = __size_pixels; ptr += 4;
3363
3364         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3365         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3366
3367         stream->readback(pixels, __size_pixels);
3368         if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
3369         if (useChecksum) {
3370                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
3371                 stream->readback(checksumBuf.get(), checksumSize);
3372                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
3373                         ALOGE("glReadPixels: GL communication error, please report this issue to b.android.com.\n");
3374                         abort();
3375                 }
3376         }
3377 }
3378
3379 void glRotatex_enc(void *self , GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
3380 {
3381
3382         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3383         IOStream *stream = ctx->m_stream;
3384         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3385         bool useChecksum = checksumCalculator->getVersion() > 0;
3386
3387          unsigned char *ptr;
3388          unsigned char *buf;
3389          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
3390          const size_t checksumSize = checksumCalculator->checksumByteSize();
3391          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3392         buf = stream->alloc(totalSize);
3393         ptr = buf;
3394         int tmp = OP_glRotatex;memcpy(ptr, &tmp, 4); ptr += 4;
3395         memcpy(ptr, &totalSize, 4);  ptr += 4;
3396
3397                 memcpy(ptr, &angle, 4); ptr += 4;
3398                 memcpy(ptr, &x, 4); ptr += 4;
3399                 memcpy(ptr, &y, 4); ptr += 4;
3400                 memcpy(ptr, &z, 4); ptr += 4;
3401
3402         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3403         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3404
3405 }
3406
3407 void glSampleCoverage_enc(void *self , GLclampf value, GLboolean invert)
3408 {
3409
3410         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3411         IOStream *stream = ctx->m_stream;
3412         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3413         bool useChecksum = checksumCalculator->getVersion() > 0;
3414
3415          unsigned char *ptr;
3416          unsigned char *buf;
3417          const size_t sizeWithoutChecksum = 8 + 4 + 1;
3418          const size_t checksumSize = checksumCalculator->checksumByteSize();
3419          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3420         buf = stream->alloc(totalSize);
3421         ptr = buf;
3422         int tmp = OP_glSampleCoverage;memcpy(ptr, &tmp, 4); ptr += 4;
3423         memcpy(ptr, &totalSize, 4);  ptr += 4;
3424
3425                 memcpy(ptr, &value, 4); ptr += 4;
3426                 memcpy(ptr, &invert, 1); ptr += 1;
3427
3428         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3429         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3430
3431 }
3432
3433 void glSampleCoveragex_enc(void *self , GLclampx value, GLboolean invert)
3434 {
3435
3436         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3437         IOStream *stream = ctx->m_stream;
3438         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3439         bool useChecksum = checksumCalculator->getVersion() > 0;
3440
3441          unsigned char *ptr;
3442          unsigned char *buf;
3443          const size_t sizeWithoutChecksum = 8 + 4 + 1;
3444          const size_t checksumSize = checksumCalculator->checksumByteSize();
3445          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3446         buf = stream->alloc(totalSize);
3447         ptr = buf;
3448         int tmp = OP_glSampleCoveragex;memcpy(ptr, &tmp, 4); ptr += 4;
3449         memcpy(ptr, &totalSize, 4);  ptr += 4;
3450
3451                 memcpy(ptr, &value, 4); ptr += 4;
3452                 memcpy(ptr, &invert, 1); ptr += 1;
3453
3454         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3455         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3456
3457 }
3458
3459 void glScalex_enc(void *self , GLfixed x, GLfixed y, GLfixed z)
3460 {
3461
3462         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3463         IOStream *stream = ctx->m_stream;
3464         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3465         bool useChecksum = checksumCalculator->getVersion() > 0;
3466
3467          unsigned char *ptr;
3468          unsigned char *buf;
3469          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
3470          const size_t checksumSize = checksumCalculator->checksumByteSize();
3471          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3472         buf = stream->alloc(totalSize);
3473         ptr = buf;
3474         int tmp = OP_glScalex;memcpy(ptr, &tmp, 4); ptr += 4;
3475         memcpy(ptr, &totalSize, 4);  ptr += 4;
3476
3477                 memcpy(ptr, &x, 4); ptr += 4;
3478                 memcpy(ptr, &y, 4); ptr += 4;
3479                 memcpy(ptr, &z, 4); ptr += 4;
3480
3481         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3482         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3483
3484 }
3485
3486 void glScissor_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height)
3487 {
3488
3489         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3490         IOStream *stream = ctx->m_stream;
3491         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3492         bool useChecksum = checksumCalculator->getVersion() > 0;
3493
3494          unsigned char *ptr;
3495          unsigned char *buf;
3496          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
3497          const size_t checksumSize = checksumCalculator->checksumByteSize();
3498          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3499         buf = stream->alloc(totalSize);
3500         ptr = buf;
3501         int tmp = OP_glScissor;memcpy(ptr, &tmp, 4); ptr += 4;
3502         memcpy(ptr, &totalSize, 4);  ptr += 4;
3503
3504                 memcpy(ptr, &x, 4); ptr += 4;
3505                 memcpy(ptr, &y, 4); ptr += 4;
3506                 memcpy(ptr, &width, 4); ptr += 4;
3507                 memcpy(ptr, &height, 4); ptr += 4;
3508
3509         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3510         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3511
3512 }
3513
3514 void glShadeModel_enc(void *self , GLenum mode)
3515 {
3516
3517         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3518         IOStream *stream = ctx->m_stream;
3519         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3520         bool useChecksum = checksumCalculator->getVersion() > 0;
3521
3522          unsigned char *ptr;
3523          unsigned char *buf;
3524          const size_t sizeWithoutChecksum = 8 + 4;
3525          const size_t checksumSize = checksumCalculator->checksumByteSize();
3526          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3527         buf = stream->alloc(totalSize);
3528         ptr = buf;
3529         int tmp = OP_glShadeModel;memcpy(ptr, &tmp, 4); ptr += 4;
3530         memcpy(ptr, &totalSize, 4);  ptr += 4;
3531
3532                 memcpy(ptr, &mode, 4); ptr += 4;
3533
3534         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3535         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3536
3537 }
3538
3539 void glStencilFunc_enc(void *self , GLenum func, GLint ref, GLuint mask)
3540 {
3541
3542         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3543         IOStream *stream = ctx->m_stream;
3544         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3545         bool useChecksum = checksumCalculator->getVersion() > 0;
3546
3547          unsigned char *ptr;
3548          unsigned char *buf;
3549          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
3550          const size_t checksumSize = checksumCalculator->checksumByteSize();
3551          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3552         buf = stream->alloc(totalSize);
3553         ptr = buf;
3554         int tmp = OP_glStencilFunc;memcpy(ptr, &tmp, 4); ptr += 4;
3555         memcpy(ptr, &totalSize, 4);  ptr += 4;
3556
3557                 memcpy(ptr, &func, 4); ptr += 4;
3558                 memcpy(ptr, &ref, 4); ptr += 4;
3559                 memcpy(ptr, &mask, 4); ptr += 4;
3560
3561         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3562         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3563
3564 }
3565
3566 void glStencilMask_enc(void *self , GLuint mask)
3567 {
3568
3569         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3570         IOStream *stream = ctx->m_stream;
3571         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3572         bool useChecksum = checksumCalculator->getVersion() > 0;
3573
3574          unsigned char *ptr;
3575          unsigned char *buf;
3576          const size_t sizeWithoutChecksum = 8 + 4;
3577          const size_t checksumSize = checksumCalculator->checksumByteSize();
3578          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3579         buf = stream->alloc(totalSize);
3580         ptr = buf;
3581         int tmp = OP_glStencilMask;memcpy(ptr, &tmp, 4); ptr += 4;
3582         memcpy(ptr, &totalSize, 4);  ptr += 4;
3583
3584                 memcpy(ptr, &mask, 4); ptr += 4;
3585
3586         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3587         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3588
3589 }
3590
3591 void glStencilOp_enc(void *self , GLenum fail, GLenum zfail, GLenum zpass)
3592 {
3593
3594         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3595         IOStream *stream = ctx->m_stream;
3596         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3597         bool useChecksum = checksumCalculator->getVersion() > 0;
3598
3599          unsigned char *ptr;
3600          unsigned char *buf;
3601          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
3602          const size_t checksumSize = checksumCalculator->checksumByteSize();
3603          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3604         buf = stream->alloc(totalSize);
3605         ptr = buf;
3606         int tmp = OP_glStencilOp;memcpy(ptr, &tmp, 4); ptr += 4;
3607         memcpy(ptr, &totalSize, 4);  ptr += 4;
3608
3609                 memcpy(ptr, &fail, 4); ptr += 4;
3610                 memcpy(ptr, &zfail, 4); ptr += 4;
3611                 memcpy(ptr, &zpass, 4); ptr += 4;
3612
3613         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3614         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3615
3616 }
3617
3618 void glTexEnvi_enc(void *self , GLenum target, GLenum pname, GLint param)
3619 {
3620
3621         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3622         IOStream *stream = ctx->m_stream;
3623         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3624         bool useChecksum = checksumCalculator->getVersion() > 0;
3625
3626          unsigned char *ptr;
3627          unsigned char *buf;
3628          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
3629          const size_t checksumSize = checksumCalculator->checksumByteSize();
3630          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3631         buf = stream->alloc(totalSize);
3632         ptr = buf;
3633         int tmp = OP_glTexEnvi;memcpy(ptr, &tmp, 4); ptr += 4;
3634         memcpy(ptr, &totalSize, 4);  ptr += 4;
3635
3636                 memcpy(ptr, &target, 4); ptr += 4;
3637                 memcpy(ptr, &pname, 4); ptr += 4;
3638                 memcpy(ptr, &param, 4); ptr += 4;
3639
3640         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3641         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3642
3643 }
3644
3645 void glTexEnvx_enc(void *self , GLenum target, GLenum pname, GLfixed param)
3646 {
3647
3648         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3649         IOStream *stream = ctx->m_stream;
3650         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3651         bool useChecksum = checksumCalculator->getVersion() > 0;
3652
3653          unsigned char *ptr;
3654          unsigned char *buf;
3655          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
3656          const size_t checksumSize = checksumCalculator->checksumByteSize();
3657          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3658         buf = stream->alloc(totalSize);
3659         ptr = buf;
3660         int tmp = OP_glTexEnvx;memcpy(ptr, &tmp, 4); ptr += 4;
3661         memcpy(ptr, &totalSize, 4);  ptr += 4;
3662
3663                 memcpy(ptr, &target, 4); ptr += 4;
3664                 memcpy(ptr, &pname, 4); ptr += 4;
3665                 memcpy(ptr, &param, 4); ptr += 4;
3666
3667         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3668         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3669
3670 }
3671
3672 void glTexEnviv_enc(void *self , GLenum target, GLenum pname, const GLint* params)
3673 {
3674
3675         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3676         IOStream *stream = ctx->m_stream;
3677         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3678         bool useChecksum = checksumCalculator->getVersion() > 0;
3679
3680         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
3681          unsigned char *ptr;
3682          unsigned char *buf;
3683          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
3684          const size_t checksumSize = checksumCalculator->checksumByteSize();
3685          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3686         buf = stream->alloc(totalSize);
3687         ptr = buf;
3688         int tmp = OP_glTexEnviv;memcpy(ptr, &tmp, 4); ptr += 4;
3689         memcpy(ptr, &totalSize, 4);  ptr += 4;
3690
3691                 memcpy(ptr, &target, 4); ptr += 4;
3692                 memcpy(ptr, &pname, 4); ptr += 4;
3693         *(unsigned int *)(ptr) = __size_params; ptr += 4;
3694         memcpy(ptr, params, __size_params);ptr += __size_params;
3695
3696         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3697         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3698
3699 }
3700
3701 void glTexEnvxv_enc(void *self , GLenum target, GLenum pname, const GLfixed* params)
3702 {
3703
3704         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3705         IOStream *stream = ctx->m_stream;
3706         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3707         bool useChecksum = checksumCalculator->getVersion() > 0;
3708
3709         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
3710          unsigned char *ptr;
3711          unsigned char *buf;
3712          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
3713          const size_t checksumSize = checksumCalculator->checksumByteSize();
3714          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3715         buf = stream->alloc(totalSize);
3716         ptr = buf;
3717         int tmp = OP_glTexEnvxv;memcpy(ptr, &tmp, 4); ptr += 4;
3718         memcpy(ptr, &totalSize, 4);  ptr += 4;
3719
3720                 memcpy(ptr, &target, 4); ptr += 4;
3721                 memcpy(ptr, &pname, 4); ptr += 4;
3722         *(unsigned int *)(ptr) = __size_params; ptr += 4;
3723         memcpy(ptr, params, __size_params);ptr += __size_params;
3724
3725         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3726         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3727
3728 }
3729
3730 void glTexImage2D_enc(void *self , GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
3731 {
3732
3733         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3734         IOStream *stream = ctx->m_stream;
3735         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3736         bool useChecksum = checksumCalculator->getVersion() > 0;
3737
3738         const unsigned int __size_pixels = ((pixels != NULL) ?  glesv1_enc::pixelDataSize(self, width, height, format, type, 0) : 0);
3739          unsigned char *ptr;
3740          unsigned char *buf;
3741          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
3742          const size_t checksumSize = checksumCalculator->checksumByteSize();
3743          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3744         buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
3745         ptr = buf;
3746         int tmp = OP_glTexImage2D;memcpy(ptr, &tmp, 4); ptr += 4;
3747         memcpy(ptr, &totalSize, 4);  ptr += 4;
3748
3749                 memcpy(ptr, &target, 4); ptr += 4;
3750                 memcpy(ptr, &level, 4); ptr += 4;
3751                 memcpy(ptr, &internalformat, 4); ptr += 4;
3752                 memcpy(ptr, &width, 4); ptr += 4;
3753                 memcpy(ptr, &height, 4); ptr += 4;
3754                 memcpy(ptr, &border, 4); ptr += 4;
3755                 memcpy(ptr, &format, 4); ptr += 4;
3756                 memcpy(ptr, &type, 4); ptr += 4;
3757
3758         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3759         stream->flush();
3760         stream->writeFully(&__size_pixels,4);
3761         if (useChecksum) checksumCalculator->addBuffer(&__size_pixels,4);
3762         if (pixels != NULL) {
3763                 stream->writeFully(pixels, __size_pixels);
3764                 if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
3765         }
3766         buf = stream->alloc(checksumSize);
3767         if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
3768
3769 }
3770
3771 void glTexParameteri_enc(void *self , GLenum target, GLenum pname, GLint param)
3772 {
3773
3774         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3775         IOStream *stream = ctx->m_stream;
3776         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3777         bool useChecksum = checksumCalculator->getVersion() > 0;
3778
3779          unsigned char *ptr;
3780          unsigned char *buf;
3781          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
3782          const size_t checksumSize = checksumCalculator->checksumByteSize();
3783          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3784         buf = stream->alloc(totalSize);
3785         ptr = buf;
3786         int tmp = OP_glTexParameteri;memcpy(ptr, &tmp, 4); ptr += 4;
3787         memcpy(ptr, &totalSize, 4);  ptr += 4;
3788
3789                 memcpy(ptr, &target, 4); ptr += 4;
3790                 memcpy(ptr, &pname, 4); ptr += 4;
3791                 memcpy(ptr, &param, 4); ptr += 4;
3792
3793         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3794         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3795
3796 }
3797
3798 void glTexParameterx_enc(void *self , GLenum target, GLenum pname, GLfixed param)
3799 {
3800
3801         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3802         IOStream *stream = ctx->m_stream;
3803         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3804         bool useChecksum = checksumCalculator->getVersion() > 0;
3805
3806          unsigned char *ptr;
3807          unsigned char *buf;
3808          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
3809          const size_t checksumSize = checksumCalculator->checksumByteSize();
3810          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3811         buf = stream->alloc(totalSize);
3812         ptr = buf;
3813         int tmp = OP_glTexParameterx;memcpy(ptr, &tmp, 4); ptr += 4;
3814         memcpy(ptr, &totalSize, 4);  ptr += 4;
3815
3816                 memcpy(ptr, &target, 4); ptr += 4;
3817                 memcpy(ptr, &pname, 4); ptr += 4;
3818                 memcpy(ptr, &param, 4); ptr += 4;
3819
3820         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3821         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3822
3823 }
3824
3825 void glTexParameteriv_enc(void *self , GLenum target, GLenum pname, const GLint* params)
3826 {
3827
3828         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3829         IOStream *stream = ctx->m_stream;
3830         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3831         bool useChecksum = checksumCalculator->getVersion() > 0;
3832
3833         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
3834          unsigned char *ptr;
3835          unsigned char *buf;
3836          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
3837          const size_t checksumSize = checksumCalculator->checksumByteSize();
3838          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3839         buf = stream->alloc(totalSize);
3840         ptr = buf;
3841         int tmp = OP_glTexParameteriv;memcpy(ptr, &tmp, 4); ptr += 4;
3842         memcpy(ptr, &totalSize, 4);  ptr += 4;
3843
3844                 memcpy(ptr, &target, 4); ptr += 4;
3845                 memcpy(ptr, &pname, 4); ptr += 4;
3846         *(unsigned int *)(ptr) = __size_params; ptr += 4;
3847         memcpy(ptr, params, __size_params);ptr += __size_params;
3848
3849         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3850         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3851
3852 }
3853
3854 void glTexParameterxv_enc(void *self , GLenum target, GLenum pname, const GLfixed* params)
3855 {
3856
3857         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3858         IOStream *stream = ctx->m_stream;
3859         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3860         bool useChecksum = checksumCalculator->getVersion() > 0;
3861
3862         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
3863          unsigned char *ptr;
3864          unsigned char *buf;
3865          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
3866          const size_t checksumSize = checksumCalculator->checksumByteSize();
3867          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3868         buf = stream->alloc(totalSize);
3869         ptr = buf;
3870         int tmp = OP_glTexParameterxv;memcpy(ptr, &tmp, 4); ptr += 4;
3871         memcpy(ptr, &totalSize, 4);  ptr += 4;
3872
3873                 memcpy(ptr, &target, 4); ptr += 4;
3874                 memcpy(ptr, &pname, 4); ptr += 4;
3875         *(unsigned int *)(ptr) = __size_params; ptr += 4;
3876         memcpy(ptr, params, __size_params);ptr += __size_params;
3877
3878         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3879         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3880
3881 }
3882
3883 void glTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
3884 {
3885
3886         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3887         IOStream *stream = ctx->m_stream;
3888         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3889         bool useChecksum = checksumCalculator->getVersion() > 0;
3890
3891         const unsigned int __size_pixels = ((pixels != NULL) ?  glesv1_enc::pixelDataSize(self, width, height, format, type, 0) : 0);
3892          unsigned char *ptr;
3893          unsigned char *buf;
3894          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
3895          const size_t checksumSize = checksumCalculator->checksumByteSize();
3896          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3897         buf = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
3898         ptr = buf;
3899         int tmp = OP_glTexSubImage2D;memcpy(ptr, &tmp, 4); ptr += 4;
3900         memcpy(ptr, &totalSize, 4);  ptr += 4;
3901
3902                 memcpy(ptr, &target, 4); ptr += 4;
3903                 memcpy(ptr, &level, 4); ptr += 4;
3904                 memcpy(ptr, &xoffset, 4); ptr += 4;
3905                 memcpy(ptr, &yoffset, 4); ptr += 4;
3906                 memcpy(ptr, &width, 4); ptr += 4;
3907                 memcpy(ptr, &height, 4); ptr += 4;
3908                 memcpy(ptr, &format, 4); ptr += 4;
3909                 memcpy(ptr, &type, 4); ptr += 4;
3910
3911         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3912         stream->flush();
3913         stream->writeFully(&__size_pixels,4);
3914         if (useChecksum) checksumCalculator->addBuffer(&__size_pixels,4);
3915         if (pixels != NULL) {
3916                 stream->writeFully(pixels, __size_pixels);
3917                 if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
3918         }
3919         buf = stream->alloc(checksumSize);
3920         if (useChecksum) checksumCalculator->writeChecksum(buf, checksumSize);
3921
3922 }
3923
3924 void glTranslatex_enc(void *self , GLfixed x, GLfixed y, GLfixed z)
3925 {
3926
3927         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3928         IOStream *stream = ctx->m_stream;
3929         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3930         bool useChecksum = checksumCalculator->getVersion() > 0;
3931
3932          unsigned char *ptr;
3933          unsigned char *buf;
3934          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
3935          const size_t checksumSize = checksumCalculator->checksumByteSize();
3936          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3937         buf = stream->alloc(totalSize);
3938         ptr = buf;
3939         int tmp = OP_glTranslatex;memcpy(ptr, &tmp, 4); ptr += 4;
3940         memcpy(ptr, &totalSize, 4);  ptr += 4;
3941
3942                 memcpy(ptr, &x, 4); ptr += 4;
3943                 memcpy(ptr, &y, 4); ptr += 4;
3944                 memcpy(ptr, &z, 4); ptr += 4;
3945
3946         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3947         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3948
3949 }
3950
3951 void glViewport_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height)
3952 {
3953
3954         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3955         IOStream *stream = ctx->m_stream;
3956         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3957         bool useChecksum = checksumCalculator->getVersion() > 0;
3958
3959          unsigned char *ptr;
3960          unsigned char *buf;
3961          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
3962          const size_t checksumSize = checksumCalculator->checksumByteSize();
3963          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3964         buf = stream->alloc(totalSize);
3965         ptr = buf;
3966         int tmp = OP_glViewport;memcpy(ptr, &tmp, 4); ptr += 4;
3967         memcpy(ptr, &totalSize, 4);  ptr += 4;
3968
3969                 memcpy(ptr, &x, 4); ptr += 4;
3970                 memcpy(ptr, &y, 4); ptr += 4;
3971                 memcpy(ptr, &width, 4); ptr += 4;
3972                 memcpy(ptr, &height, 4); ptr += 4;
3973
3974         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
3975         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
3976
3977 }
3978
3979 void glVertexPointerOffset_enc(void *self , GLint size, GLenum type, GLsizei stride, GLuint offset)
3980 {
3981
3982         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
3983         IOStream *stream = ctx->m_stream;
3984         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
3985         bool useChecksum = checksumCalculator->getVersion() > 0;
3986
3987          unsigned char *ptr;
3988          unsigned char *buf;
3989          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
3990          const size_t checksumSize = checksumCalculator->checksumByteSize();
3991          const size_t totalSize = sizeWithoutChecksum + checksumSize;
3992         buf = stream->alloc(totalSize);
3993         ptr = buf;
3994         int tmp = OP_glVertexPointerOffset;memcpy(ptr, &tmp, 4); ptr += 4;
3995         memcpy(ptr, &totalSize, 4);  ptr += 4;
3996
3997                 memcpy(ptr, &size, 4); ptr += 4;
3998                 memcpy(ptr, &type, 4); ptr += 4;
3999                 memcpy(ptr, &stride, 4); ptr += 4;
4000                 memcpy(ptr, &offset, 4); ptr += 4;
4001
4002         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4003         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4004
4005 }
4006
4007 void glColorPointerOffset_enc(void *self , GLint size, GLenum type, GLsizei stride, GLuint offset)
4008 {
4009
4010         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4011         IOStream *stream = ctx->m_stream;
4012         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4013         bool useChecksum = checksumCalculator->getVersion() > 0;
4014
4015          unsigned char *ptr;
4016          unsigned char *buf;
4017          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
4018          const size_t checksumSize = checksumCalculator->checksumByteSize();
4019          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4020         buf = stream->alloc(totalSize);
4021         ptr = buf;
4022         int tmp = OP_glColorPointerOffset;memcpy(ptr, &tmp, 4); ptr += 4;
4023         memcpy(ptr, &totalSize, 4);  ptr += 4;
4024
4025                 memcpy(ptr, &size, 4); ptr += 4;
4026                 memcpy(ptr, &type, 4); ptr += 4;
4027                 memcpy(ptr, &stride, 4); ptr += 4;
4028                 memcpy(ptr, &offset, 4); ptr += 4;
4029
4030         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4031         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4032
4033 }
4034
4035 void glNormalPointerOffset_enc(void *self , GLenum type, GLsizei stride, GLuint offset)
4036 {
4037
4038         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4039         IOStream *stream = ctx->m_stream;
4040         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4041         bool useChecksum = checksumCalculator->getVersion() > 0;
4042
4043          unsigned char *ptr;
4044          unsigned char *buf;
4045          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
4046          const size_t checksumSize = checksumCalculator->checksumByteSize();
4047          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4048         buf = stream->alloc(totalSize);
4049         ptr = buf;
4050         int tmp = OP_glNormalPointerOffset;memcpy(ptr, &tmp, 4); ptr += 4;
4051         memcpy(ptr, &totalSize, 4);  ptr += 4;
4052
4053                 memcpy(ptr, &type, 4); ptr += 4;
4054                 memcpy(ptr, &stride, 4); ptr += 4;
4055                 memcpy(ptr, &offset, 4); ptr += 4;
4056
4057         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4058         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4059
4060 }
4061
4062 void glPointSizePointerOffset_enc(void *self , GLenum type, GLsizei stride, GLuint offset)
4063 {
4064
4065         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4066         IOStream *stream = ctx->m_stream;
4067         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4068         bool useChecksum = checksumCalculator->getVersion() > 0;
4069
4070          unsigned char *ptr;
4071          unsigned char *buf;
4072          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
4073          const size_t checksumSize = checksumCalculator->checksumByteSize();
4074          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4075         buf = stream->alloc(totalSize);
4076         ptr = buf;
4077         int tmp = OP_glPointSizePointerOffset;memcpy(ptr, &tmp, 4); ptr += 4;
4078         memcpy(ptr, &totalSize, 4);  ptr += 4;
4079
4080                 memcpy(ptr, &type, 4); ptr += 4;
4081                 memcpy(ptr, &stride, 4); ptr += 4;
4082                 memcpy(ptr, &offset, 4); ptr += 4;
4083
4084         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4085         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4086
4087 }
4088
4089 void glTexCoordPointerOffset_enc(void *self , GLint size, GLenum type, GLsizei stride, GLuint offset)
4090 {
4091
4092         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4093         IOStream *stream = ctx->m_stream;
4094         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4095         bool useChecksum = checksumCalculator->getVersion() > 0;
4096
4097          unsigned char *ptr;
4098          unsigned char *buf;
4099          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
4100          const size_t checksumSize = checksumCalculator->checksumByteSize();
4101          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4102         buf = stream->alloc(totalSize);
4103         ptr = buf;
4104         int tmp = OP_glTexCoordPointerOffset;memcpy(ptr, &tmp, 4); ptr += 4;
4105         memcpy(ptr, &totalSize, 4);  ptr += 4;
4106
4107                 memcpy(ptr, &size, 4); ptr += 4;
4108                 memcpy(ptr, &type, 4); ptr += 4;
4109                 memcpy(ptr, &stride, 4); ptr += 4;
4110                 memcpy(ptr, &offset, 4); ptr += 4;
4111
4112         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4113         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4114
4115 }
4116
4117 void glWeightPointerOffset_enc(void *self , GLint size, GLenum type, GLsizei stride, GLuint offset)
4118 {
4119
4120         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4121         IOStream *stream = ctx->m_stream;
4122         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4123         bool useChecksum = checksumCalculator->getVersion() > 0;
4124
4125          unsigned char *ptr;
4126          unsigned char *buf;
4127          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
4128          const size_t checksumSize = checksumCalculator->checksumByteSize();
4129          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4130         buf = stream->alloc(totalSize);
4131         ptr = buf;
4132         int tmp = OP_glWeightPointerOffset;memcpy(ptr, &tmp, 4); ptr += 4;
4133         memcpy(ptr, &totalSize, 4);  ptr += 4;
4134
4135                 memcpy(ptr, &size, 4); ptr += 4;
4136                 memcpy(ptr, &type, 4); ptr += 4;
4137                 memcpy(ptr, &stride, 4); ptr += 4;
4138                 memcpy(ptr, &offset, 4); ptr += 4;
4139
4140         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4141         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4142
4143 }
4144
4145 void glMatrixIndexPointerOffset_enc(void *self , GLint size, GLenum type, GLsizei stride, GLuint offset)
4146 {
4147
4148         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4149         IOStream *stream = ctx->m_stream;
4150         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4151         bool useChecksum = checksumCalculator->getVersion() > 0;
4152
4153          unsigned char *ptr;
4154          unsigned char *buf;
4155          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
4156          const size_t checksumSize = checksumCalculator->checksumByteSize();
4157          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4158         buf = stream->alloc(totalSize);
4159         ptr = buf;
4160         int tmp = OP_glMatrixIndexPointerOffset;memcpy(ptr, &tmp, 4); ptr += 4;
4161         memcpy(ptr, &totalSize, 4);  ptr += 4;
4162
4163                 memcpy(ptr, &size, 4); ptr += 4;
4164                 memcpy(ptr, &type, 4); ptr += 4;
4165                 memcpy(ptr, &stride, 4); ptr += 4;
4166                 memcpy(ptr, &offset, 4); ptr += 4;
4167
4168         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4169         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4170
4171 }
4172
4173 void glVertexPointerData_enc(void *self , GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
4174 {
4175
4176         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4177         IOStream *stream = ctx->m_stream;
4178         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4179         bool useChecksum = checksumCalculator->getVersion() > 0;
4180
4181         const unsigned int __size_data =  datalen;
4182          unsigned char *ptr;
4183          unsigned char *buf;
4184          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_data + 4 + 1*4;
4185          const size_t checksumSize = checksumCalculator->checksumByteSize();
4186          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4187         buf = stream->alloc(totalSize);
4188         ptr = buf;
4189         int tmp = OP_glVertexPointerData;memcpy(ptr, &tmp, 4); ptr += 4;
4190         memcpy(ptr, &totalSize, 4);  ptr += 4;
4191
4192                 memcpy(ptr, &size, 4); ptr += 4;
4193                 memcpy(ptr, &type, 4); ptr += 4;
4194                 memcpy(ptr, &stride, 4); ptr += 4;
4195         *(unsigned int *)(ptr) = __size_data; ptr += 4;
4196          glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen);ptr += __size_data;
4197                 memcpy(ptr, &datalen, 4); ptr += 4;
4198
4199         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4200         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4201
4202 }
4203
4204 void glColorPointerData_enc(void *self , GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
4205 {
4206
4207         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4208         IOStream *stream = ctx->m_stream;
4209         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4210         bool useChecksum = checksumCalculator->getVersion() > 0;
4211
4212         const unsigned int __size_data =  datalen;
4213          unsigned char *ptr;
4214          unsigned char *buf;
4215          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_data + 4 + 1*4;
4216          const size_t checksumSize = checksumCalculator->checksumByteSize();
4217          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4218         buf = stream->alloc(totalSize);
4219         ptr = buf;
4220         int tmp = OP_glColorPointerData;memcpy(ptr, &tmp, 4); ptr += 4;
4221         memcpy(ptr, &totalSize, 4);  ptr += 4;
4222
4223                 memcpy(ptr, &size, 4); ptr += 4;
4224                 memcpy(ptr, &type, 4); ptr += 4;
4225                 memcpy(ptr, &stride, 4); ptr += 4;
4226         *(unsigned int *)(ptr) = __size_data; ptr += 4;
4227          glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen);ptr += __size_data;
4228                 memcpy(ptr, &datalen, 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 glNormalPointerData_enc(void *self , GLenum type, GLsizei stride, void* data, GLuint datalen)
4236 {
4237
4238         gl_encoder_context_t *ctx = (gl_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_data =  datalen;
4244          unsigned char *ptr;
4245          unsigned char *buf;
4246          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_data + 4 + 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_glNormalPointerData;memcpy(ptr, &tmp, 4); ptr += 4;
4252         memcpy(ptr, &totalSize, 4);  ptr += 4;
4253
4254                 memcpy(ptr, &type, 4); ptr += 4;
4255                 memcpy(ptr, &stride, 4); ptr += 4;
4256         *(unsigned int *)(ptr) = __size_data; ptr += 4;
4257          glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, 3, type, stride, datalen);ptr += __size_data;
4258                 memcpy(ptr, &datalen, 4); ptr += 4;
4259
4260         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4261         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4262
4263 }
4264
4265 void glTexCoordPointerData_enc(void *self , GLint unit, GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
4266 {
4267
4268         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4269         IOStream *stream = ctx->m_stream;
4270         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4271         bool useChecksum = checksumCalculator->getVersion() > 0;
4272
4273         const unsigned int __size_data =  datalen;
4274          unsigned char *ptr;
4275          unsigned char *buf;
4276          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + __size_data + 4 + 1*4;
4277          const size_t checksumSize = checksumCalculator->checksumByteSize();
4278          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4279         buf = stream->alloc(totalSize);
4280         ptr = buf;
4281         int tmp = OP_glTexCoordPointerData;memcpy(ptr, &tmp, 4); ptr += 4;
4282         memcpy(ptr, &totalSize, 4);  ptr += 4;
4283
4284                 memcpy(ptr, &unit, 4); ptr += 4;
4285                 memcpy(ptr, &size, 4); ptr += 4;
4286                 memcpy(ptr, &type, 4); ptr += 4;
4287                 memcpy(ptr, &stride, 4); ptr += 4;
4288         *(unsigned int *)(ptr) = __size_data; ptr += 4;
4289          glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen);ptr += __size_data;
4290                 memcpy(ptr, &datalen, 4); ptr += 4;
4291
4292         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4293         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4294
4295 }
4296
4297 void glPointSizePointerData_enc(void *self , GLenum type, GLsizei stride, void* data, GLuint datalen)
4298 {
4299
4300         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4301         IOStream *stream = ctx->m_stream;
4302         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4303         bool useChecksum = checksumCalculator->getVersion() > 0;
4304
4305         const unsigned int __size_data =  datalen;
4306          unsigned char *ptr;
4307          unsigned char *buf;
4308          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_data + 4 + 1*4;
4309          const size_t checksumSize = checksumCalculator->checksumByteSize();
4310          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4311         buf = stream->alloc(totalSize);
4312         ptr = buf;
4313         int tmp = OP_glPointSizePointerData;memcpy(ptr, &tmp, 4); ptr += 4;
4314         memcpy(ptr, &totalSize, 4);  ptr += 4;
4315
4316                 memcpy(ptr, &type, 4); ptr += 4;
4317                 memcpy(ptr, &stride, 4); ptr += 4;
4318         *(unsigned int *)(ptr) = __size_data; ptr += 4;
4319          glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, 1, type, stride, datalen);ptr += __size_data;
4320                 memcpy(ptr, &datalen, 4); ptr += 4;
4321
4322         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4323         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4324
4325 }
4326
4327 void glWeightPointerData_enc(void *self , GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
4328 {
4329
4330         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4331         IOStream *stream = ctx->m_stream;
4332         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4333         bool useChecksum = checksumCalculator->getVersion() > 0;
4334
4335         const unsigned int __size_data =  datalen;
4336          unsigned char *ptr;
4337          unsigned char *buf;
4338          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_data + 4 + 1*4;
4339          const size_t checksumSize = checksumCalculator->checksumByteSize();
4340          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4341         buf = stream->alloc(totalSize);
4342         ptr = buf;
4343         int tmp = OP_glWeightPointerData;memcpy(ptr, &tmp, 4); ptr += 4;
4344         memcpy(ptr, &totalSize, 4);  ptr += 4;
4345
4346                 memcpy(ptr, &size, 4); ptr += 4;
4347                 memcpy(ptr, &type, 4); ptr += 4;
4348                 memcpy(ptr, &stride, 4); ptr += 4;
4349         *(unsigned int *)(ptr) = __size_data; ptr += 4;
4350          glUtilsPackPointerData((unsigned char *)ptr, (unsigned char*)data, size, type, stride, datalen);ptr += __size_data;
4351                 memcpy(ptr, &datalen, 4); ptr += 4;
4352
4353         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4354         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4355
4356 }
4357
4358 void glMatrixIndexPointerData_enc(void *self , GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
4359 {
4360
4361         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4362         IOStream *stream = ctx->m_stream;
4363         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4364         bool useChecksum = checksumCalculator->getVersion() > 0;
4365
4366         const unsigned int __size_data =  datalen;
4367          unsigned char *ptr;
4368          unsigned char *buf;
4369          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_data + 4 + 1*4;
4370          const size_t checksumSize = checksumCalculator->checksumByteSize();
4371          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4372         buf = stream->alloc(totalSize);
4373         ptr = buf;
4374         int tmp = OP_glMatrixIndexPointerData;memcpy(ptr, &tmp, 4); ptr += 4;
4375         memcpy(ptr, &totalSize, 4);  ptr += 4;
4376
4377                 memcpy(ptr, &size, 4); ptr += 4;
4378                 memcpy(ptr, &type, 4); ptr += 4;
4379                 memcpy(ptr, &stride, 4); ptr += 4;
4380         *(unsigned int *)(ptr) = __size_data; ptr += 4;
4381          glUtilsPackPointerData((unsigned char *)ptr, (unsigned char*)data, size, type, stride, datalen);ptr += __size_data;
4382                 memcpy(ptr, &datalen, 4); ptr += 4;
4383
4384         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4385         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4386
4387 }
4388
4389 void glDrawElementsOffset_enc(void *self , GLenum mode, GLsizei count, GLenum type, GLuint offset)
4390 {
4391
4392         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4393         IOStream *stream = ctx->m_stream;
4394         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4395         bool useChecksum = checksumCalculator->getVersion() > 0;
4396
4397          unsigned char *ptr;
4398          unsigned char *buf;
4399          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
4400          const size_t checksumSize = checksumCalculator->checksumByteSize();
4401          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4402         buf = stream->alloc(totalSize);
4403         ptr = buf;
4404         int tmp = OP_glDrawElementsOffset;memcpy(ptr, &tmp, 4); ptr += 4;
4405         memcpy(ptr, &totalSize, 4);  ptr += 4;
4406
4407                 memcpy(ptr, &mode, 4); ptr += 4;
4408                 memcpy(ptr, &count, 4); ptr += 4;
4409                 memcpy(ptr, &type, 4); ptr += 4;
4410                 memcpy(ptr, &offset, 4); ptr += 4;
4411
4412         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4413         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4414
4415 }
4416
4417 void glDrawElementsData_enc(void *self , GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen)
4418 {
4419
4420         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4421         IOStream *stream = ctx->m_stream;
4422         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4423         bool useChecksum = checksumCalculator->getVersion() > 0;
4424
4425         const unsigned int __size_data =  datalen;
4426          unsigned char *ptr;
4427          unsigned char *buf;
4428          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_data + 4 + 1*4;
4429          const size_t checksumSize = checksumCalculator->checksumByteSize();
4430          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4431         buf = stream->alloc(totalSize);
4432         ptr = buf;
4433         int tmp = OP_glDrawElementsData;memcpy(ptr, &tmp, 4); ptr += 4;
4434         memcpy(ptr, &totalSize, 4);  ptr += 4;
4435
4436                 memcpy(ptr, &mode, 4); ptr += 4;
4437                 memcpy(ptr, &count, 4); ptr += 4;
4438                 memcpy(ptr, &type, 4); ptr += 4;
4439         *(unsigned int *)(ptr) = __size_data; ptr += 4;
4440         memcpy(ptr, data, __size_data);ptr += __size_data;
4441                 memcpy(ptr, &datalen, 4); ptr += 4;
4442
4443         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4444         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4445
4446 }
4447
4448 void glGetCompressedTextureFormats_enc(void *self , int count, GLint* formats)
4449 {
4450
4451         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4452         IOStream *stream = ctx->m_stream;
4453         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4454         bool useChecksum = checksumCalculator->getVersion() > 0;
4455
4456         const unsigned int __size_formats =  (count * sizeof(GLint));
4457          unsigned char *ptr;
4458          unsigned char *buf;
4459          const size_t sizeWithoutChecksum = 8 + 4 + __size_formats + 1*4;
4460          const size_t checksumSize = checksumCalculator->checksumByteSize();
4461          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4462         buf = stream->alloc(totalSize);
4463         ptr = buf;
4464         int tmp = OP_glGetCompressedTextureFormats;memcpy(ptr, &tmp, 4); ptr += 4;
4465         memcpy(ptr, &totalSize, 4);  ptr += 4;
4466
4467                 memcpy(ptr, &count, 4); ptr += 4;
4468         *(unsigned int *)(ptr) = __size_formats; ptr += 4;
4469
4470         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4471         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4472
4473         stream->readback(formats, __size_formats);
4474         if (useChecksum) checksumCalculator->addBuffer(formats, __size_formats);
4475         if (useChecksum) {
4476                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
4477                 stream->readback(checksumBuf.get(), checksumSize);
4478                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
4479                         ALOGE("glGetCompressedTextureFormats: GL communication error, please report this issue to b.android.com.\n");
4480                         abort();
4481                 }
4482         }
4483 }
4484
4485 int glFinishRoundTrip_enc(void *self )
4486 {
4487
4488         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4489         IOStream *stream = ctx->m_stream;
4490         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4491         bool useChecksum = checksumCalculator->getVersion() > 0;
4492
4493          unsigned char *ptr;
4494          unsigned char *buf;
4495          const size_t sizeWithoutChecksum = 8;
4496          const size_t checksumSize = checksumCalculator->checksumByteSize();
4497          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4498         buf = stream->alloc(totalSize);
4499         ptr = buf;
4500         int tmp = OP_glFinishRoundTrip;memcpy(ptr, &tmp, 4); ptr += 4;
4501         memcpy(ptr, &totalSize, 4);  ptr += 4;
4502
4503
4504         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4505         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4506
4507
4508         int retval;
4509         stream->readback(&retval, 4);
4510         if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
4511         if (useChecksum) {
4512                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
4513                 stream->readback(checksumBuf.get(), checksumSize);
4514                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
4515                         ALOGE("glFinishRoundTrip: GL communication error, please report this issue to b.android.com.\n");
4516                         abort();
4517                 }
4518         }
4519         return retval;
4520 }
4521
4522 void glBlendEquationSeparateOES_enc(void *self , GLenum modeRGB, GLenum modeAlpha)
4523 {
4524
4525         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4526         IOStream *stream = ctx->m_stream;
4527         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4528         bool useChecksum = checksumCalculator->getVersion() > 0;
4529
4530          unsigned char *ptr;
4531          unsigned char *buf;
4532          const size_t sizeWithoutChecksum = 8 + 4 + 4;
4533          const size_t checksumSize = checksumCalculator->checksumByteSize();
4534          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4535         buf = stream->alloc(totalSize);
4536         ptr = buf;
4537         int tmp = OP_glBlendEquationSeparateOES;memcpy(ptr, &tmp, 4); ptr += 4;
4538         memcpy(ptr, &totalSize, 4);  ptr += 4;
4539
4540                 memcpy(ptr, &modeRGB, 4); ptr += 4;
4541                 memcpy(ptr, &modeAlpha, 4); ptr += 4;
4542
4543         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4544         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4545
4546 }
4547
4548 void glBlendFuncSeparateOES_enc(void *self , GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
4549 {
4550
4551         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4552         IOStream *stream = ctx->m_stream;
4553         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4554         bool useChecksum = checksumCalculator->getVersion() > 0;
4555
4556          unsigned char *ptr;
4557          unsigned char *buf;
4558          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
4559          const size_t checksumSize = checksumCalculator->checksumByteSize();
4560          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4561         buf = stream->alloc(totalSize);
4562         ptr = buf;
4563         int tmp = OP_glBlendFuncSeparateOES;memcpy(ptr, &tmp, 4); ptr += 4;
4564         memcpy(ptr, &totalSize, 4);  ptr += 4;
4565
4566                 memcpy(ptr, &srcRGB, 4); ptr += 4;
4567                 memcpy(ptr, &dstRGB, 4); ptr += 4;
4568                 memcpy(ptr, &srcAlpha, 4); ptr += 4;
4569                 memcpy(ptr, &dstAlpha, 4); ptr += 4;
4570
4571         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4572         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4573
4574 }
4575
4576 void glBlendEquationOES_enc(void *self , GLenum mode)
4577 {
4578
4579         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4580         IOStream *stream = ctx->m_stream;
4581         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4582         bool useChecksum = checksumCalculator->getVersion() > 0;
4583
4584          unsigned char *ptr;
4585          unsigned char *buf;
4586          const size_t sizeWithoutChecksum = 8 + 4;
4587          const size_t checksumSize = checksumCalculator->checksumByteSize();
4588          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4589         buf = stream->alloc(totalSize);
4590         ptr = buf;
4591         int tmp = OP_glBlendEquationOES;memcpy(ptr, &tmp, 4); ptr += 4;
4592         memcpy(ptr, &totalSize, 4);  ptr += 4;
4593
4594                 memcpy(ptr, &mode, 4); ptr += 4;
4595
4596         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4597         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4598
4599 }
4600
4601 void glDrawTexsOES_enc(void *self , GLshort x, GLshort y, GLshort z, GLshort width, GLshort height)
4602 {
4603
4604         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4605         IOStream *stream = ctx->m_stream;
4606         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4607         bool useChecksum = checksumCalculator->getVersion() > 0;
4608
4609          unsigned char *ptr;
4610          unsigned char *buf;
4611          const size_t sizeWithoutChecksum = 8 + 2 + 2 + 2 + 2 + 2;
4612          const size_t checksumSize = checksumCalculator->checksumByteSize();
4613          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4614         buf = stream->alloc(totalSize);
4615         ptr = buf;
4616         int tmp = OP_glDrawTexsOES;memcpy(ptr, &tmp, 4); ptr += 4;
4617         memcpy(ptr, &totalSize, 4);  ptr += 4;
4618
4619                 memcpy(ptr, &x, 2); ptr += 2;
4620                 memcpy(ptr, &y, 2); ptr += 2;
4621                 memcpy(ptr, &z, 2); ptr += 2;
4622                 memcpy(ptr, &width, 2); ptr += 2;
4623                 memcpy(ptr, &height, 2); ptr += 2;
4624
4625         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4626         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4627
4628 }
4629
4630 void glDrawTexiOES_enc(void *self , GLint x, GLint y, GLint z, GLint width, GLint height)
4631 {
4632
4633         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4634         IOStream *stream = ctx->m_stream;
4635         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4636         bool useChecksum = checksumCalculator->getVersion() > 0;
4637
4638          unsigned char *ptr;
4639          unsigned char *buf;
4640          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
4641          const size_t checksumSize = checksumCalculator->checksumByteSize();
4642          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4643         buf = stream->alloc(totalSize);
4644         ptr = buf;
4645         int tmp = OP_glDrawTexiOES;memcpy(ptr, &tmp, 4); ptr += 4;
4646         memcpy(ptr, &totalSize, 4);  ptr += 4;
4647
4648                 memcpy(ptr, &x, 4); ptr += 4;
4649                 memcpy(ptr, &y, 4); ptr += 4;
4650                 memcpy(ptr, &z, 4); ptr += 4;
4651                 memcpy(ptr, &width, 4); ptr += 4;
4652                 memcpy(ptr, &height, 4); ptr += 4;
4653
4654         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4655         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4656
4657 }
4658
4659 void glDrawTexxOES_enc(void *self , GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height)
4660 {
4661
4662         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4663         IOStream *stream = ctx->m_stream;
4664         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4665         bool useChecksum = checksumCalculator->getVersion() > 0;
4666
4667          unsigned char *ptr;
4668          unsigned char *buf;
4669          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
4670          const size_t checksumSize = checksumCalculator->checksumByteSize();
4671          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4672         buf = stream->alloc(totalSize);
4673         ptr = buf;
4674         int tmp = OP_glDrawTexxOES;memcpy(ptr, &tmp, 4); ptr += 4;
4675         memcpy(ptr, &totalSize, 4);  ptr += 4;
4676
4677                 memcpy(ptr, &x, 4); ptr += 4;
4678                 memcpy(ptr, &y, 4); ptr += 4;
4679                 memcpy(ptr, &z, 4); ptr += 4;
4680                 memcpy(ptr, &width, 4); ptr += 4;
4681                 memcpy(ptr, &height, 4); ptr += 4;
4682
4683         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4684         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4685
4686 }
4687
4688 void glDrawTexsvOES_enc(void *self , const GLshort* coords)
4689 {
4690
4691         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4692         IOStream *stream = ctx->m_stream;
4693         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4694         bool useChecksum = checksumCalculator->getVersion() > 0;
4695
4696         const unsigned int __size_coords =  (5 * sizeof(GLshort));
4697          unsigned char *ptr;
4698          unsigned char *buf;
4699          const size_t sizeWithoutChecksum = 8 + __size_coords + 1*4;
4700          const size_t checksumSize = checksumCalculator->checksumByteSize();
4701          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4702         buf = stream->alloc(totalSize);
4703         ptr = buf;
4704         int tmp = OP_glDrawTexsvOES;memcpy(ptr, &tmp, 4); ptr += 4;
4705         memcpy(ptr, &totalSize, 4);  ptr += 4;
4706
4707         *(unsigned int *)(ptr) = __size_coords; ptr += 4;
4708         memcpy(ptr, coords, __size_coords);ptr += __size_coords;
4709
4710         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4711         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4712
4713 }
4714
4715 void glDrawTexivOES_enc(void *self , const GLint* coords)
4716 {
4717
4718         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4719         IOStream *stream = ctx->m_stream;
4720         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4721         bool useChecksum = checksumCalculator->getVersion() > 0;
4722
4723         const unsigned int __size_coords =  (5 * sizeof(GLint));
4724          unsigned char *ptr;
4725          unsigned char *buf;
4726          const size_t sizeWithoutChecksum = 8 + __size_coords + 1*4;
4727          const size_t checksumSize = checksumCalculator->checksumByteSize();
4728          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4729         buf = stream->alloc(totalSize);
4730         ptr = buf;
4731         int tmp = OP_glDrawTexivOES;memcpy(ptr, &tmp, 4); ptr += 4;
4732         memcpy(ptr, &totalSize, 4);  ptr += 4;
4733
4734         *(unsigned int *)(ptr) = __size_coords; ptr += 4;
4735         memcpy(ptr, coords, __size_coords);ptr += __size_coords;
4736
4737         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4738         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4739
4740 }
4741
4742 void glDrawTexxvOES_enc(void *self , const GLfixed* coords)
4743 {
4744
4745         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4746         IOStream *stream = ctx->m_stream;
4747         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4748         bool useChecksum = checksumCalculator->getVersion() > 0;
4749
4750         const unsigned int __size_coords =  (5 * sizeof(GLfixed));
4751          unsigned char *ptr;
4752          unsigned char *buf;
4753          const size_t sizeWithoutChecksum = 8 + __size_coords + 1*4;
4754          const size_t checksumSize = checksumCalculator->checksumByteSize();
4755          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4756         buf = stream->alloc(totalSize);
4757         ptr = buf;
4758         int tmp = OP_glDrawTexxvOES;memcpy(ptr, &tmp, 4); ptr += 4;
4759         memcpy(ptr, &totalSize, 4);  ptr += 4;
4760
4761         *(unsigned int *)(ptr) = __size_coords; ptr += 4;
4762         memcpy(ptr, coords, __size_coords);ptr += __size_coords;
4763
4764         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4765         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4766
4767 }
4768
4769 void glDrawTexfOES_enc(void *self , GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height)
4770 {
4771
4772         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4773         IOStream *stream = ctx->m_stream;
4774         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4775         bool useChecksum = checksumCalculator->getVersion() > 0;
4776
4777          unsigned char *ptr;
4778          unsigned char *buf;
4779          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
4780          const size_t checksumSize = checksumCalculator->checksumByteSize();
4781          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4782         buf = stream->alloc(totalSize);
4783         ptr = buf;
4784         int tmp = OP_glDrawTexfOES;memcpy(ptr, &tmp, 4); ptr += 4;
4785         memcpy(ptr, &totalSize, 4);  ptr += 4;
4786
4787                 memcpy(ptr, &x, 4); ptr += 4;
4788                 memcpy(ptr, &y, 4); ptr += 4;
4789                 memcpy(ptr, &z, 4); ptr += 4;
4790                 memcpy(ptr, &width, 4); ptr += 4;
4791                 memcpy(ptr, &height, 4); ptr += 4;
4792
4793         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4794         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4795
4796 }
4797
4798 void glDrawTexfvOES_enc(void *self , const GLfloat* coords)
4799 {
4800
4801         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4802         IOStream *stream = ctx->m_stream;
4803         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4804         bool useChecksum = checksumCalculator->getVersion() > 0;
4805
4806         const unsigned int __size_coords =  (5 * sizeof(GLfloat));
4807          unsigned char *ptr;
4808          unsigned char *buf;
4809          const size_t sizeWithoutChecksum = 8 + __size_coords + 1*4;
4810          const size_t checksumSize = checksumCalculator->checksumByteSize();
4811          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4812         buf = stream->alloc(totalSize);
4813         ptr = buf;
4814         int tmp = OP_glDrawTexfvOES;memcpy(ptr, &tmp, 4); ptr += 4;
4815         memcpy(ptr, &totalSize, 4);  ptr += 4;
4816
4817         *(unsigned int *)(ptr) = __size_coords; ptr += 4;
4818         memcpy(ptr, coords, __size_coords);ptr += __size_coords;
4819
4820         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4821         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4822
4823 }
4824
4825 void glEGLImageTargetTexture2DOES_enc(void *self , GLenum target, GLeglImageOES image)
4826 {
4827
4828         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4829         IOStream *stream = ctx->m_stream;
4830         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4831         bool useChecksum = checksumCalculator->getVersion() > 0;
4832
4833          unsigned char *ptr;
4834          unsigned char *buf;
4835          const size_t sizeWithoutChecksum = 8 + 4 + 4;
4836          const size_t checksumSize = checksumCalculator->checksumByteSize();
4837          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4838         buf = stream->alloc(totalSize);
4839         ptr = buf;
4840         int tmp = OP_glEGLImageTargetTexture2DOES;memcpy(ptr, &tmp, 4); ptr += 4;
4841         memcpy(ptr, &totalSize, 4);  ptr += 4;
4842
4843                 memcpy(ptr, &target, 4); ptr += 4;
4844                 memcpy(ptr, &image, 4); ptr += 4;
4845
4846         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4847         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4848
4849 }
4850
4851 void glEGLImageTargetRenderbufferStorageOES_enc(void *self , GLenum target, GLeglImageOES image)
4852 {
4853
4854         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4855         IOStream *stream = ctx->m_stream;
4856         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4857         bool useChecksum = checksumCalculator->getVersion() > 0;
4858
4859          unsigned char *ptr;
4860          unsigned char *buf;
4861          const size_t sizeWithoutChecksum = 8 + 4 + 4;
4862          const size_t checksumSize = checksumCalculator->checksumByteSize();
4863          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4864         buf = stream->alloc(totalSize);
4865         ptr = buf;
4866         int tmp = OP_glEGLImageTargetRenderbufferStorageOES;memcpy(ptr, &tmp, 4); ptr += 4;
4867         memcpy(ptr, &totalSize, 4);  ptr += 4;
4868
4869                 memcpy(ptr, &target, 4); ptr += 4;
4870                 memcpy(ptr, &image, 4); ptr += 4;
4871
4872         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4873         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4874
4875 }
4876
4877 void glAlphaFuncxOES_enc(void *self , GLenum func, GLclampx ref)
4878 {
4879
4880         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4881         IOStream *stream = ctx->m_stream;
4882         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4883         bool useChecksum = checksumCalculator->getVersion() > 0;
4884
4885          unsigned char *ptr;
4886          unsigned char *buf;
4887          const size_t sizeWithoutChecksum = 8 + 4 + 4;
4888          const size_t checksumSize = checksumCalculator->checksumByteSize();
4889          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4890         buf = stream->alloc(totalSize);
4891         ptr = buf;
4892         int tmp = OP_glAlphaFuncxOES;memcpy(ptr, &tmp, 4); ptr += 4;
4893         memcpy(ptr, &totalSize, 4);  ptr += 4;
4894
4895                 memcpy(ptr, &func, 4); ptr += 4;
4896                 memcpy(ptr, &ref, 4); ptr += 4;
4897
4898         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4899         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4900
4901 }
4902
4903 void glClearColorxOES_enc(void *self , GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
4904 {
4905
4906         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4907         IOStream *stream = ctx->m_stream;
4908         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4909         bool useChecksum = checksumCalculator->getVersion() > 0;
4910
4911          unsigned char *ptr;
4912          unsigned char *buf;
4913          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
4914          const size_t checksumSize = checksumCalculator->checksumByteSize();
4915          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4916         buf = stream->alloc(totalSize);
4917         ptr = buf;
4918         int tmp = OP_glClearColorxOES;memcpy(ptr, &tmp, 4); ptr += 4;
4919         memcpy(ptr, &totalSize, 4);  ptr += 4;
4920
4921                 memcpy(ptr, &red, 4); ptr += 4;
4922                 memcpy(ptr, &green, 4); ptr += 4;
4923                 memcpy(ptr, &blue, 4); ptr += 4;
4924                 memcpy(ptr, &alpha, 4); ptr += 4;
4925
4926         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4927         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4928
4929 }
4930
4931 void glClearDepthxOES_enc(void *self , GLclampx depth)
4932 {
4933
4934         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4935         IOStream *stream = ctx->m_stream;
4936         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4937         bool useChecksum = checksumCalculator->getVersion() > 0;
4938
4939          unsigned char *ptr;
4940          unsigned char *buf;
4941          const size_t sizeWithoutChecksum = 8 + 4;
4942          const size_t checksumSize = checksumCalculator->checksumByteSize();
4943          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4944         buf = stream->alloc(totalSize);
4945         ptr = buf;
4946         int tmp = OP_glClearDepthxOES;memcpy(ptr, &tmp, 4); ptr += 4;
4947         memcpy(ptr, &totalSize, 4);  ptr += 4;
4948
4949                 memcpy(ptr, &depth, 4); ptr += 4;
4950
4951         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4952         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4953
4954 }
4955
4956 void glClipPlanexOES_enc(void *self , GLenum plane, const GLfixed* equation)
4957 {
4958
4959         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4960         IOStream *stream = ctx->m_stream;
4961         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4962         bool useChecksum = checksumCalculator->getVersion() > 0;
4963
4964         const unsigned int __size_equation =  (4 * sizeof(GLfixed));
4965          unsigned char *ptr;
4966          unsigned char *buf;
4967          const size_t sizeWithoutChecksum = 8 + 4 + __size_equation + 1*4;
4968          const size_t checksumSize = checksumCalculator->checksumByteSize();
4969          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4970         buf = stream->alloc(totalSize);
4971         ptr = buf;
4972         int tmp = OP_glClipPlanexOES;memcpy(ptr, &tmp, 4); ptr += 4;
4973         memcpy(ptr, &totalSize, 4);  ptr += 4;
4974
4975                 memcpy(ptr, &plane, 4); ptr += 4;
4976         *(unsigned int *)(ptr) = __size_equation; ptr += 4;
4977         memcpy(ptr, equation, __size_equation);ptr += __size_equation;
4978
4979         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
4980         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
4981
4982 }
4983
4984 void glClipPlanexIMG_enc(void *self , GLenum plane, const GLfixed* equation)
4985 {
4986
4987         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
4988         IOStream *stream = ctx->m_stream;
4989         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
4990         bool useChecksum = checksumCalculator->getVersion() > 0;
4991
4992         const unsigned int __size_equation =  (4 * sizeof(GLfixed));
4993          unsigned char *ptr;
4994          unsigned char *buf;
4995          const size_t sizeWithoutChecksum = 8 + 4 + __size_equation + 1*4;
4996          const size_t checksumSize = checksumCalculator->checksumByteSize();
4997          const size_t totalSize = sizeWithoutChecksum + checksumSize;
4998         buf = stream->alloc(totalSize);
4999         ptr = buf;
5000         int tmp = OP_glClipPlanexIMG;memcpy(ptr, &tmp, 4); ptr += 4;
5001         memcpy(ptr, &totalSize, 4);  ptr += 4;
5002
5003                 memcpy(ptr, &plane, 4); ptr += 4;
5004         *(unsigned int *)(ptr) = __size_equation; ptr += 4;
5005         memcpy(ptr, equation, __size_equation);ptr += __size_equation;
5006
5007         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5008         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5009
5010 }
5011
5012 void glColor4xOES_enc(void *self , GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
5013 {
5014
5015         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5016         IOStream *stream = ctx->m_stream;
5017         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5018         bool useChecksum = checksumCalculator->getVersion() > 0;
5019
5020          unsigned char *ptr;
5021          unsigned char *buf;
5022          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
5023          const size_t checksumSize = checksumCalculator->checksumByteSize();
5024          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5025         buf = stream->alloc(totalSize);
5026         ptr = buf;
5027         int tmp = OP_glColor4xOES;memcpy(ptr, &tmp, 4); ptr += 4;
5028         memcpy(ptr, &totalSize, 4);  ptr += 4;
5029
5030                 memcpy(ptr, &red, 4); ptr += 4;
5031                 memcpy(ptr, &green, 4); ptr += 4;
5032                 memcpy(ptr, &blue, 4); ptr += 4;
5033                 memcpy(ptr, &alpha, 4); ptr += 4;
5034
5035         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5036         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5037
5038 }
5039
5040 void glDepthRangexOES_enc(void *self , GLclampx zNear, GLclampx zFar)
5041 {
5042
5043         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5044         IOStream *stream = ctx->m_stream;
5045         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5046         bool useChecksum = checksumCalculator->getVersion() > 0;
5047
5048          unsigned char *ptr;
5049          unsigned char *buf;
5050          const size_t sizeWithoutChecksum = 8 + 4 + 4;
5051          const size_t checksumSize = checksumCalculator->checksumByteSize();
5052          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5053         buf = stream->alloc(totalSize);
5054         ptr = buf;
5055         int tmp = OP_glDepthRangexOES;memcpy(ptr, &tmp, 4); ptr += 4;
5056         memcpy(ptr, &totalSize, 4);  ptr += 4;
5057
5058                 memcpy(ptr, &zNear, 4); ptr += 4;
5059                 memcpy(ptr, &zFar, 4); ptr += 4;
5060
5061         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5062         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5063
5064 }
5065
5066 void glFogxOES_enc(void *self , GLenum pname, GLfixed param)
5067 {
5068
5069         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5070         IOStream *stream = ctx->m_stream;
5071         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5072         bool useChecksum = checksumCalculator->getVersion() > 0;
5073
5074          unsigned char *ptr;
5075          unsigned char *buf;
5076          const size_t sizeWithoutChecksum = 8 + 4 + 4;
5077          const size_t checksumSize = checksumCalculator->checksumByteSize();
5078          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5079         buf = stream->alloc(totalSize);
5080         ptr = buf;
5081         int tmp = OP_glFogxOES;memcpy(ptr, &tmp, 4); ptr += 4;
5082         memcpy(ptr, &totalSize, 4);  ptr += 4;
5083
5084                 memcpy(ptr, &pname, 4); ptr += 4;
5085                 memcpy(ptr, &param, 4); ptr += 4;
5086
5087         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5088         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5089
5090 }
5091
5092 void glFogxvOES_enc(void *self , GLenum pname, const GLfixed* params)
5093 {
5094
5095         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5096         IOStream *stream = ctx->m_stream;
5097         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5098         bool useChecksum = checksumCalculator->getVersion() > 0;
5099
5100         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
5101          unsigned char *ptr;
5102          unsigned char *buf;
5103          const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4;
5104          const size_t checksumSize = checksumCalculator->checksumByteSize();
5105          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5106         buf = stream->alloc(totalSize);
5107         ptr = buf;
5108         int tmp = OP_glFogxvOES;memcpy(ptr, &tmp, 4); ptr += 4;
5109         memcpy(ptr, &totalSize, 4);  ptr += 4;
5110
5111                 memcpy(ptr, &pname, 4); ptr += 4;
5112         *(unsigned int *)(ptr) = __size_params; ptr += 4;
5113         memcpy(ptr, params, __size_params);ptr += __size_params;
5114
5115         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5116         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5117
5118 }
5119
5120 void glFrustumxOES_enc(void *self , GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
5121 {
5122
5123         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5124         IOStream *stream = ctx->m_stream;
5125         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5126         bool useChecksum = checksumCalculator->getVersion() > 0;
5127
5128          unsigned char *ptr;
5129          unsigned char *buf;
5130          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4;
5131          const size_t checksumSize = checksumCalculator->checksumByteSize();
5132          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5133         buf = stream->alloc(totalSize);
5134         ptr = buf;
5135         int tmp = OP_glFrustumxOES;memcpy(ptr, &tmp, 4); ptr += 4;
5136         memcpy(ptr, &totalSize, 4);  ptr += 4;
5137
5138                 memcpy(ptr, &left, 4); ptr += 4;
5139                 memcpy(ptr, &right, 4); ptr += 4;
5140                 memcpy(ptr, &bottom, 4); ptr += 4;
5141                 memcpy(ptr, &top, 4); ptr += 4;
5142                 memcpy(ptr, &zNear, 4); ptr += 4;
5143                 memcpy(ptr, &zFar, 4); ptr += 4;
5144
5145         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5146         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5147
5148 }
5149
5150 void glGetClipPlanexOES_enc(void *self , GLenum pname, GLfixed* eqn)
5151 {
5152
5153         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5154         IOStream *stream = ctx->m_stream;
5155         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5156         bool useChecksum = checksumCalculator->getVersion() > 0;
5157
5158         const unsigned int __size_eqn =  (4 * sizeof(GLfixed));
5159          unsigned char *ptr;
5160          unsigned char *buf;
5161          const size_t sizeWithoutChecksum = 8 + 4 + __size_eqn + 1*4;
5162          const size_t checksumSize = checksumCalculator->checksumByteSize();
5163          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5164         buf = stream->alloc(totalSize);
5165         ptr = buf;
5166         int tmp = OP_glGetClipPlanexOES;memcpy(ptr, &tmp, 4); ptr += 4;
5167         memcpy(ptr, &totalSize, 4);  ptr += 4;
5168
5169                 memcpy(ptr, &pname, 4); ptr += 4;
5170         *(unsigned int *)(ptr) = __size_eqn; ptr += 4;
5171
5172         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5173         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5174
5175         stream->readback(eqn, __size_eqn);
5176         if (useChecksum) checksumCalculator->addBuffer(eqn, __size_eqn);
5177         if (useChecksum) {
5178                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
5179                 stream->readback(checksumBuf.get(), checksumSize);
5180                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
5181                         ALOGE("glGetClipPlanexOES: GL communication error, please report this issue to b.android.com.\n");
5182                         abort();
5183                 }
5184         }
5185 }
5186
5187 void glGetClipPlanex_enc(void *self , GLenum pname, GLfixed* eqn)
5188 {
5189
5190         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5191         IOStream *stream = ctx->m_stream;
5192         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5193         bool useChecksum = checksumCalculator->getVersion() > 0;
5194
5195         const unsigned int __size_eqn =  (4 * sizeof(GLfixed));
5196          unsigned char *ptr;
5197          unsigned char *buf;
5198          const size_t sizeWithoutChecksum = 8 + 4 + __size_eqn + 1*4;
5199          const size_t checksumSize = checksumCalculator->checksumByteSize();
5200          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5201         buf = stream->alloc(totalSize);
5202         ptr = buf;
5203         int tmp = OP_glGetClipPlanex;memcpy(ptr, &tmp, 4); ptr += 4;
5204         memcpy(ptr, &totalSize, 4);  ptr += 4;
5205
5206                 memcpy(ptr, &pname, 4); ptr += 4;
5207         *(unsigned int *)(ptr) = __size_eqn; ptr += 4;
5208
5209         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5210         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5211
5212         stream->readback(eqn, __size_eqn);
5213         if (useChecksum) checksumCalculator->addBuffer(eqn, __size_eqn);
5214         if (useChecksum) {
5215                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
5216                 stream->readback(checksumBuf.get(), checksumSize);
5217                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
5218                         ALOGE("glGetClipPlanex: GL communication error, please report this issue to b.android.com.\n");
5219                         abort();
5220                 }
5221         }
5222 }
5223
5224 void glGetFixedvOES_enc(void *self , GLenum pname, GLfixed* params)
5225 {
5226
5227         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5228         IOStream *stream = ctx->m_stream;
5229         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5230         bool useChecksum = checksumCalculator->getVersion() > 0;
5231
5232         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
5233          unsigned char *ptr;
5234          unsigned char *buf;
5235          const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4;
5236          const size_t checksumSize = checksumCalculator->checksumByteSize();
5237          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5238         buf = stream->alloc(totalSize);
5239         ptr = buf;
5240         int tmp = OP_glGetFixedvOES;memcpy(ptr, &tmp, 4); ptr += 4;
5241         memcpy(ptr, &totalSize, 4);  ptr += 4;
5242
5243                 memcpy(ptr, &pname, 4); ptr += 4;
5244         *(unsigned int *)(ptr) = __size_params; ptr += 4;
5245
5246         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5247         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5248
5249         stream->readback(params, __size_params);
5250         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
5251         if (useChecksum) {
5252                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
5253                 stream->readback(checksumBuf.get(), checksumSize);
5254                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
5255                         ALOGE("glGetFixedvOES: GL communication error, please report this issue to b.android.com.\n");
5256                         abort();
5257                 }
5258         }
5259 }
5260
5261 void glGetLightxvOES_enc(void *self , GLenum light, GLenum pname, GLfixed* params)
5262 {
5263
5264         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5265         IOStream *stream = ctx->m_stream;
5266         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5267         bool useChecksum = checksumCalculator->getVersion() > 0;
5268
5269         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
5270          unsigned char *ptr;
5271          unsigned char *buf;
5272          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
5273          const size_t checksumSize = checksumCalculator->checksumByteSize();
5274          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5275         buf = stream->alloc(totalSize);
5276         ptr = buf;
5277         int tmp = OP_glGetLightxvOES;memcpy(ptr, &tmp, 4); ptr += 4;
5278         memcpy(ptr, &totalSize, 4);  ptr += 4;
5279
5280                 memcpy(ptr, &light, 4); ptr += 4;
5281                 memcpy(ptr, &pname, 4); ptr += 4;
5282         *(unsigned int *)(ptr) = __size_params; ptr += 4;
5283
5284         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5285         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5286
5287         stream->readback(params, __size_params);
5288         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
5289         if (useChecksum) {
5290                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
5291                 stream->readback(checksumBuf.get(), checksumSize);
5292                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
5293                         ALOGE("glGetLightxvOES: GL communication error, please report this issue to b.android.com.\n");
5294                         abort();
5295                 }
5296         }
5297 }
5298
5299 void glGetMaterialxvOES_enc(void *self , GLenum face, GLenum pname, GLfixed* params)
5300 {
5301
5302         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5303         IOStream *stream = ctx->m_stream;
5304         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5305         bool useChecksum = checksumCalculator->getVersion() > 0;
5306
5307         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
5308          unsigned char *ptr;
5309          unsigned char *buf;
5310          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
5311          const size_t checksumSize = checksumCalculator->checksumByteSize();
5312          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5313         buf = stream->alloc(totalSize);
5314         ptr = buf;
5315         int tmp = OP_glGetMaterialxvOES;memcpy(ptr, &tmp, 4); ptr += 4;
5316         memcpy(ptr, &totalSize, 4);  ptr += 4;
5317
5318                 memcpy(ptr, &face, 4); ptr += 4;
5319                 memcpy(ptr, &pname, 4); ptr += 4;
5320         *(unsigned int *)(ptr) = __size_params; ptr += 4;
5321
5322         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5323         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5324
5325         stream->readback(params, __size_params);
5326         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
5327         if (useChecksum) {
5328                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
5329                 stream->readback(checksumBuf.get(), checksumSize);
5330                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
5331                         ALOGE("glGetMaterialxvOES: GL communication error, please report this issue to b.android.com.\n");
5332                         abort();
5333                 }
5334         }
5335 }
5336
5337 void glGetTexEnvxvOES_enc(void *self , GLenum env, GLenum pname, GLfixed* params)
5338 {
5339
5340         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5341         IOStream *stream = ctx->m_stream;
5342         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5343         bool useChecksum = checksumCalculator->getVersion() > 0;
5344
5345         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
5346          unsigned char *ptr;
5347          unsigned char *buf;
5348          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
5349          const size_t checksumSize = checksumCalculator->checksumByteSize();
5350          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5351         buf = stream->alloc(totalSize);
5352         ptr = buf;
5353         int tmp = OP_glGetTexEnvxvOES;memcpy(ptr, &tmp, 4); ptr += 4;
5354         memcpy(ptr, &totalSize, 4);  ptr += 4;
5355
5356                 memcpy(ptr, &env, 4); ptr += 4;
5357                 memcpy(ptr, &pname, 4); ptr += 4;
5358         *(unsigned int *)(ptr) = __size_params; ptr += 4;
5359
5360         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5361         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5362
5363         stream->readback(params, __size_params);
5364         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
5365         if (useChecksum) {
5366                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
5367                 stream->readback(checksumBuf.get(), checksumSize);
5368                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
5369                         ALOGE("glGetTexEnvxvOES: GL communication error, please report this issue to b.android.com.\n");
5370                         abort();
5371                 }
5372         }
5373 }
5374
5375 void glGetTexParameterxvOES_enc(void *self , GLenum target, GLenum pname, GLfixed* params)
5376 {
5377
5378         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5379         IOStream *stream = ctx->m_stream;
5380         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5381         bool useChecksum = checksumCalculator->getVersion() > 0;
5382
5383         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
5384          unsigned char *ptr;
5385          unsigned char *buf;
5386          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
5387          const size_t checksumSize = checksumCalculator->checksumByteSize();
5388          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5389         buf = stream->alloc(totalSize);
5390         ptr = buf;
5391         int tmp = OP_glGetTexParameterxvOES;memcpy(ptr, &tmp, 4); ptr += 4;
5392         memcpy(ptr, &totalSize, 4);  ptr += 4;
5393
5394                 memcpy(ptr, &target, 4); ptr += 4;
5395                 memcpy(ptr, &pname, 4); ptr += 4;
5396         *(unsigned int *)(ptr) = __size_params; ptr += 4;
5397
5398         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5399         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5400
5401         stream->readback(params, __size_params);
5402         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
5403         if (useChecksum) {
5404                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
5405                 stream->readback(checksumBuf.get(), checksumSize);
5406                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
5407                         ALOGE("glGetTexParameterxvOES: GL communication error, please report this issue to b.android.com.\n");
5408                         abort();
5409                 }
5410         }
5411 }
5412
5413 void glLightModelxOES_enc(void *self , GLenum pname, GLfixed param)
5414 {
5415
5416         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5417         IOStream *stream = ctx->m_stream;
5418         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5419         bool useChecksum = checksumCalculator->getVersion() > 0;
5420
5421          unsigned char *ptr;
5422          unsigned char *buf;
5423          const size_t sizeWithoutChecksum = 8 + 4 + 4;
5424          const size_t checksumSize = checksumCalculator->checksumByteSize();
5425          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5426         buf = stream->alloc(totalSize);
5427         ptr = buf;
5428         int tmp = OP_glLightModelxOES;memcpy(ptr, &tmp, 4); ptr += 4;
5429         memcpy(ptr, &totalSize, 4);  ptr += 4;
5430
5431                 memcpy(ptr, &pname, 4); ptr += 4;
5432                 memcpy(ptr, &param, 4); ptr += 4;
5433
5434         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5435         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5436
5437 }
5438
5439 void glLightModelxvOES_enc(void *self , GLenum pname, const GLfixed* params)
5440 {
5441
5442         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5443         IOStream *stream = ctx->m_stream;
5444         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5445         bool useChecksum = checksumCalculator->getVersion() > 0;
5446
5447         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
5448          unsigned char *ptr;
5449          unsigned char *buf;
5450          const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4;
5451          const size_t checksumSize = checksumCalculator->checksumByteSize();
5452          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5453         buf = stream->alloc(totalSize);
5454         ptr = buf;
5455         int tmp = OP_glLightModelxvOES;memcpy(ptr, &tmp, 4); ptr += 4;
5456         memcpy(ptr, &totalSize, 4);  ptr += 4;
5457
5458                 memcpy(ptr, &pname, 4); ptr += 4;
5459         *(unsigned int *)(ptr) = __size_params; ptr += 4;
5460         memcpy(ptr, params, __size_params);ptr += __size_params;
5461
5462         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5463         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5464
5465 }
5466
5467 void glLightxOES_enc(void *self , GLenum light, GLenum pname, GLfixed param)
5468 {
5469
5470         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5471         IOStream *stream = ctx->m_stream;
5472         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5473         bool useChecksum = checksumCalculator->getVersion() > 0;
5474
5475          unsigned char *ptr;
5476          unsigned char *buf;
5477          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
5478          const size_t checksumSize = checksumCalculator->checksumByteSize();
5479          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5480         buf = stream->alloc(totalSize);
5481         ptr = buf;
5482         int tmp = OP_glLightxOES;memcpy(ptr, &tmp, 4); ptr += 4;
5483         memcpy(ptr, &totalSize, 4);  ptr += 4;
5484
5485                 memcpy(ptr, &light, 4); ptr += 4;
5486                 memcpy(ptr, &pname, 4); ptr += 4;
5487                 memcpy(ptr, &param, 4); ptr += 4;
5488
5489         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5490         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5491
5492 }
5493
5494 void glLightxvOES_enc(void *self , GLenum light, GLenum pname, const GLfixed* params)
5495 {
5496
5497         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5498         IOStream *stream = ctx->m_stream;
5499         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5500         bool useChecksum = checksumCalculator->getVersion() > 0;
5501
5502         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
5503          unsigned char *ptr;
5504          unsigned char *buf;
5505          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
5506          const size_t checksumSize = checksumCalculator->checksumByteSize();
5507          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5508         buf = stream->alloc(totalSize);
5509         ptr = buf;
5510         int tmp = OP_glLightxvOES;memcpy(ptr, &tmp, 4); ptr += 4;
5511         memcpy(ptr, &totalSize, 4);  ptr += 4;
5512
5513                 memcpy(ptr, &light, 4); ptr += 4;
5514                 memcpy(ptr, &pname, 4); ptr += 4;
5515         *(unsigned int *)(ptr) = __size_params; ptr += 4;
5516         memcpy(ptr, params, __size_params);ptr += __size_params;
5517
5518         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5519         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5520
5521 }
5522
5523 void glLineWidthxOES_enc(void *self , GLfixed width)
5524 {
5525
5526         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5527         IOStream *stream = ctx->m_stream;
5528         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5529         bool useChecksum = checksumCalculator->getVersion() > 0;
5530
5531          unsigned char *ptr;
5532          unsigned char *buf;
5533          const size_t sizeWithoutChecksum = 8 + 4;
5534          const size_t checksumSize = checksumCalculator->checksumByteSize();
5535          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5536         buf = stream->alloc(totalSize);
5537         ptr = buf;
5538         int tmp = OP_glLineWidthxOES;memcpy(ptr, &tmp, 4); ptr += 4;
5539         memcpy(ptr, &totalSize, 4);  ptr += 4;
5540
5541                 memcpy(ptr, &width, 4); ptr += 4;
5542
5543         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5544         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5545
5546 }
5547
5548 void glLoadMatrixxOES_enc(void *self , const GLfixed* m)
5549 {
5550
5551         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5552         IOStream *stream = ctx->m_stream;
5553         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5554         bool useChecksum = checksumCalculator->getVersion() > 0;
5555
5556         const unsigned int __size_m =  (16 * sizeof(GLfixed));
5557          unsigned char *ptr;
5558          unsigned char *buf;
5559          const size_t sizeWithoutChecksum = 8 + __size_m + 1*4;
5560          const size_t checksumSize = checksumCalculator->checksumByteSize();
5561          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5562         buf = stream->alloc(totalSize);
5563         ptr = buf;
5564         int tmp = OP_glLoadMatrixxOES;memcpy(ptr, &tmp, 4); ptr += 4;
5565         memcpy(ptr, &totalSize, 4);  ptr += 4;
5566
5567         *(unsigned int *)(ptr) = __size_m; ptr += 4;
5568         memcpy(ptr, m, __size_m);ptr += __size_m;
5569
5570         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5571         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5572
5573 }
5574
5575 void glMaterialxOES_enc(void *self , GLenum face, GLenum pname, GLfixed param)
5576 {
5577
5578         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5579         IOStream *stream = ctx->m_stream;
5580         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5581         bool useChecksum = checksumCalculator->getVersion() > 0;
5582
5583          unsigned char *ptr;
5584          unsigned char *buf;
5585          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
5586          const size_t checksumSize = checksumCalculator->checksumByteSize();
5587          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5588         buf = stream->alloc(totalSize);
5589         ptr = buf;
5590         int tmp = OP_glMaterialxOES;memcpy(ptr, &tmp, 4); ptr += 4;
5591         memcpy(ptr, &totalSize, 4);  ptr += 4;
5592
5593                 memcpy(ptr, &face, 4); ptr += 4;
5594                 memcpy(ptr, &pname, 4); ptr += 4;
5595                 memcpy(ptr, &param, 4); ptr += 4;
5596
5597         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5598         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5599
5600 }
5601
5602 void glMaterialxvOES_enc(void *self , GLenum face, GLenum pname, const GLfixed* params)
5603 {
5604
5605         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5606         IOStream *stream = ctx->m_stream;
5607         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5608         bool useChecksum = checksumCalculator->getVersion() > 0;
5609
5610         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
5611          unsigned char *ptr;
5612          unsigned char *buf;
5613          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
5614          const size_t checksumSize = checksumCalculator->checksumByteSize();
5615          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5616         buf = stream->alloc(totalSize);
5617         ptr = buf;
5618         int tmp = OP_glMaterialxvOES;memcpy(ptr, &tmp, 4); ptr += 4;
5619         memcpy(ptr, &totalSize, 4);  ptr += 4;
5620
5621                 memcpy(ptr, &face, 4); ptr += 4;
5622                 memcpy(ptr, &pname, 4); ptr += 4;
5623         *(unsigned int *)(ptr) = __size_params; ptr += 4;
5624         memcpy(ptr, params, __size_params);ptr += __size_params;
5625
5626         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5627         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5628
5629 }
5630
5631 void glMultMatrixxOES_enc(void *self , const GLfixed* m)
5632 {
5633
5634         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5635         IOStream *stream = ctx->m_stream;
5636         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5637         bool useChecksum = checksumCalculator->getVersion() > 0;
5638
5639         const unsigned int __size_m =  (16 * sizeof(GLfixed));
5640          unsigned char *ptr;
5641          unsigned char *buf;
5642          const size_t sizeWithoutChecksum = 8 + __size_m + 1*4;
5643          const size_t checksumSize = checksumCalculator->checksumByteSize();
5644          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5645         buf = stream->alloc(totalSize);
5646         ptr = buf;
5647         int tmp = OP_glMultMatrixxOES;memcpy(ptr, &tmp, 4); ptr += 4;
5648         memcpy(ptr, &totalSize, 4);  ptr += 4;
5649
5650         *(unsigned int *)(ptr) = __size_m; ptr += 4;
5651         memcpy(ptr, m, __size_m);ptr += __size_m;
5652
5653         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5654         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5655
5656 }
5657
5658 void glMultiTexCoord4xOES_enc(void *self , GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
5659 {
5660
5661         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5662         IOStream *stream = ctx->m_stream;
5663         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5664         bool useChecksum = checksumCalculator->getVersion() > 0;
5665
5666          unsigned char *ptr;
5667          unsigned char *buf;
5668          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
5669          const size_t checksumSize = checksumCalculator->checksumByteSize();
5670          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5671         buf = stream->alloc(totalSize);
5672         ptr = buf;
5673         int tmp = OP_glMultiTexCoord4xOES;memcpy(ptr, &tmp, 4); ptr += 4;
5674         memcpy(ptr, &totalSize, 4);  ptr += 4;
5675
5676                 memcpy(ptr, &target, 4); ptr += 4;
5677                 memcpy(ptr, &s, 4); ptr += 4;
5678                 memcpy(ptr, &t, 4); ptr += 4;
5679                 memcpy(ptr, &r, 4); ptr += 4;
5680                 memcpy(ptr, &q, 4); ptr += 4;
5681
5682         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5683         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5684
5685 }
5686
5687 void glNormal3xOES_enc(void *self , GLfixed nx, GLfixed ny, GLfixed nz)
5688 {
5689
5690         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5691         IOStream *stream = ctx->m_stream;
5692         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5693         bool useChecksum = checksumCalculator->getVersion() > 0;
5694
5695          unsigned char *ptr;
5696          unsigned char *buf;
5697          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
5698          const size_t checksumSize = checksumCalculator->checksumByteSize();
5699          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5700         buf = stream->alloc(totalSize);
5701         ptr = buf;
5702         int tmp = OP_glNormal3xOES;memcpy(ptr, &tmp, 4); ptr += 4;
5703         memcpy(ptr, &totalSize, 4);  ptr += 4;
5704
5705                 memcpy(ptr, &nx, 4); ptr += 4;
5706                 memcpy(ptr, &ny, 4); ptr += 4;
5707                 memcpy(ptr, &nz, 4); ptr += 4;
5708
5709         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5710         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5711
5712 }
5713
5714 void glOrthoxOES_enc(void *self , GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
5715 {
5716
5717         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5718         IOStream *stream = ctx->m_stream;
5719         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5720         bool useChecksum = checksumCalculator->getVersion() > 0;
5721
5722          unsigned char *ptr;
5723          unsigned char *buf;
5724          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4;
5725          const size_t checksumSize = checksumCalculator->checksumByteSize();
5726          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5727         buf = stream->alloc(totalSize);
5728         ptr = buf;
5729         int tmp = OP_glOrthoxOES;memcpy(ptr, &tmp, 4); ptr += 4;
5730         memcpy(ptr, &totalSize, 4);  ptr += 4;
5731
5732                 memcpy(ptr, &left, 4); ptr += 4;
5733                 memcpy(ptr, &right, 4); ptr += 4;
5734                 memcpy(ptr, &bottom, 4); ptr += 4;
5735                 memcpy(ptr, &top, 4); ptr += 4;
5736                 memcpy(ptr, &zNear, 4); ptr += 4;
5737                 memcpy(ptr, &zFar, 4); ptr += 4;
5738
5739         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5740         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5741
5742 }
5743
5744 void glPointParameterxOES_enc(void *self , GLenum pname, GLfixed param)
5745 {
5746
5747         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5748         IOStream *stream = ctx->m_stream;
5749         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5750         bool useChecksum = checksumCalculator->getVersion() > 0;
5751
5752          unsigned char *ptr;
5753          unsigned char *buf;
5754          const size_t sizeWithoutChecksum = 8 + 4 + 4;
5755          const size_t checksumSize = checksumCalculator->checksumByteSize();
5756          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5757         buf = stream->alloc(totalSize);
5758         ptr = buf;
5759         int tmp = OP_glPointParameterxOES;memcpy(ptr, &tmp, 4); ptr += 4;
5760         memcpy(ptr, &totalSize, 4);  ptr += 4;
5761
5762                 memcpy(ptr, &pname, 4); ptr += 4;
5763                 memcpy(ptr, &param, 4); ptr += 4;
5764
5765         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5766         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5767
5768 }
5769
5770 void glPointParameterxvOES_enc(void *self , GLenum pname, const GLfixed* params)
5771 {
5772
5773         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5774         IOStream *stream = ctx->m_stream;
5775         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5776         bool useChecksum = checksumCalculator->getVersion() > 0;
5777
5778         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
5779          unsigned char *ptr;
5780          unsigned char *buf;
5781          const size_t sizeWithoutChecksum = 8 + 4 + __size_params + 1*4;
5782          const size_t checksumSize = checksumCalculator->checksumByteSize();
5783          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5784         buf = stream->alloc(totalSize);
5785         ptr = buf;
5786         int tmp = OP_glPointParameterxvOES;memcpy(ptr, &tmp, 4); ptr += 4;
5787         memcpy(ptr, &totalSize, 4);  ptr += 4;
5788
5789                 memcpy(ptr, &pname, 4); ptr += 4;
5790         *(unsigned int *)(ptr) = __size_params; ptr += 4;
5791         memcpy(ptr, params, __size_params);ptr += __size_params;
5792
5793         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5794         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5795
5796 }
5797
5798 void glPointSizexOES_enc(void *self , GLfixed size)
5799 {
5800
5801         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5802         IOStream *stream = ctx->m_stream;
5803         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5804         bool useChecksum = checksumCalculator->getVersion() > 0;
5805
5806          unsigned char *ptr;
5807          unsigned char *buf;
5808          const size_t sizeWithoutChecksum = 8 + 4;
5809          const size_t checksumSize = checksumCalculator->checksumByteSize();
5810          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5811         buf = stream->alloc(totalSize);
5812         ptr = buf;
5813         int tmp = OP_glPointSizexOES;memcpy(ptr, &tmp, 4); ptr += 4;
5814         memcpy(ptr, &totalSize, 4);  ptr += 4;
5815
5816                 memcpy(ptr, &size, 4); ptr += 4;
5817
5818         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5819         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5820
5821 }
5822
5823 void glPolygonOffsetxOES_enc(void *self , GLfixed factor, GLfixed units)
5824 {
5825
5826         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5827         IOStream *stream = ctx->m_stream;
5828         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5829         bool useChecksum = checksumCalculator->getVersion() > 0;
5830
5831          unsigned char *ptr;
5832          unsigned char *buf;
5833          const size_t sizeWithoutChecksum = 8 + 4 + 4;
5834          const size_t checksumSize = checksumCalculator->checksumByteSize();
5835          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5836         buf = stream->alloc(totalSize);
5837         ptr = buf;
5838         int tmp = OP_glPolygonOffsetxOES;memcpy(ptr, &tmp, 4); ptr += 4;
5839         memcpy(ptr, &totalSize, 4);  ptr += 4;
5840
5841                 memcpy(ptr, &factor, 4); ptr += 4;
5842                 memcpy(ptr, &units, 4); ptr += 4;
5843
5844         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5845         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5846
5847 }
5848
5849 void glRotatexOES_enc(void *self , GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
5850 {
5851
5852         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5853         IOStream *stream = ctx->m_stream;
5854         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5855         bool useChecksum = checksumCalculator->getVersion() > 0;
5856
5857          unsigned char *ptr;
5858          unsigned char *buf;
5859          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
5860          const size_t checksumSize = checksumCalculator->checksumByteSize();
5861          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5862         buf = stream->alloc(totalSize);
5863         ptr = buf;
5864         int tmp = OP_glRotatexOES;memcpy(ptr, &tmp, 4); ptr += 4;
5865         memcpy(ptr, &totalSize, 4);  ptr += 4;
5866
5867                 memcpy(ptr, &angle, 4); ptr += 4;
5868                 memcpy(ptr, &x, 4); ptr += 4;
5869                 memcpy(ptr, &y, 4); ptr += 4;
5870                 memcpy(ptr, &z, 4); ptr += 4;
5871
5872         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5873         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5874
5875 }
5876
5877 void glSampleCoveragexOES_enc(void *self , GLclampx value, GLboolean invert)
5878 {
5879
5880         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5881         IOStream *stream = ctx->m_stream;
5882         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5883         bool useChecksum = checksumCalculator->getVersion() > 0;
5884
5885          unsigned char *ptr;
5886          unsigned char *buf;
5887          const size_t sizeWithoutChecksum = 8 + 4 + 1;
5888          const size_t checksumSize = checksumCalculator->checksumByteSize();
5889          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5890         buf = stream->alloc(totalSize);
5891         ptr = buf;
5892         int tmp = OP_glSampleCoveragexOES;memcpy(ptr, &tmp, 4); ptr += 4;
5893         memcpy(ptr, &totalSize, 4);  ptr += 4;
5894
5895                 memcpy(ptr, &value, 4); ptr += 4;
5896                 memcpy(ptr, &invert, 1); ptr += 1;
5897
5898         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5899         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5900
5901 }
5902
5903 void glScalexOES_enc(void *self , GLfixed x, GLfixed y, GLfixed z)
5904 {
5905
5906         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5907         IOStream *stream = ctx->m_stream;
5908         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5909         bool useChecksum = checksumCalculator->getVersion() > 0;
5910
5911          unsigned char *ptr;
5912          unsigned char *buf;
5913          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
5914          const size_t checksumSize = checksumCalculator->checksumByteSize();
5915          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5916         buf = stream->alloc(totalSize);
5917         ptr = buf;
5918         int tmp = OP_glScalexOES;memcpy(ptr, &tmp, 4); ptr += 4;
5919         memcpy(ptr, &totalSize, 4);  ptr += 4;
5920
5921                 memcpy(ptr, &x, 4); ptr += 4;
5922                 memcpy(ptr, &y, 4); ptr += 4;
5923                 memcpy(ptr, &z, 4); ptr += 4;
5924
5925         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5926         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5927
5928 }
5929
5930 void glTexEnvxOES_enc(void *self , GLenum target, GLenum pname, GLfixed param)
5931 {
5932
5933         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5934         IOStream *stream = ctx->m_stream;
5935         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5936         bool useChecksum = checksumCalculator->getVersion() > 0;
5937
5938          unsigned char *ptr;
5939          unsigned char *buf;
5940          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
5941          const size_t checksumSize = checksumCalculator->checksumByteSize();
5942          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5943         buf = stream->alloc(totalSize);
5944         ptr = buf;
5945         int tmp = OP_glTexEnvxOES;memcpy(ptr, &tmp, 4); ptr += 4;
5946         memcpy(ptr, &totalSize, 4);  ptr += 4;
5947
5948                 memcpy(ptr, &target, 4); ptr += 4;
5949                 memcpy(ptr, &pname, 4); ptr += 4;
5950                 memcpy(ptr, &param, 4); ptr += 4;
5951
5952         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5953         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5954
5955 }
5956
5957 void glTexEnvxvOES_enc(void *self , GLenum target, GLenum pname, const GLfixed* params)
5958 {
5959
5960         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5961         IOStream *stream = ctx->m_stream;
5962         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5963         bool useChecksum = checksumCalculator->getVersion() > 0;
5964
5965         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
5966          unsigned char *ptr;
5967          unsigned char *buf;
5968          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
5969          const size_t checksumSize = checksumCalculator->checksumByteSize();
5970          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5971         buf = stream->alloc(totalSize);
5972         ptr = buf;
5973         int tmp = OP_glTexEnvxvOES;memcpy(ptr, &tmp, 4); ptr += 4;
5974         memcpy(ptr, &totalSize, 4);  ptr += 4;
5975
5976                 memcpy(ptr, &target, 4); ptr += 4;
5977                 memcpy(ptr, &pname, 4); ptr += 4;
5978         *(unsigned int *)(ptr) = __size_params; ptr += 4;
5979         memcpy(ptr, params, __size_params);ptr += __size_params;
5980
5981         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
5982         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
5983
5984 }
5985
5986 void glTexParameterxOES_enc(void *self , GLenum target, GLenum pname, GLfixed param)
5987 {
5988
5989         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
5990         IOStream *stream = ctx->m_stream;
5991         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
5992         bool useChecksum = checksumCalculator->getVersion() > 0;
5993
5994          unsigned char *ptr;
5995          unsigned char *buf;
5996          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
5997          const size_t checksumSize = checksumCalculator->checksumByteSize();
5998          const size_t totalSize = sizeWithoutChecksum + checksumSize;
5999         buf = stream->alloc(totalSize);
6000         ptr = buf;
6001         int tmp = OP_glTexParameterxOES;memcpy(ptr, &tmp, 4); ptr += 4;
6002         memcpy(ptr, &totalSize, 4);  ptr += 4;
6003
6004                 memcpy(ptr, &target, 4); ptr += 4;
6005                 memcpy(ptr, &pname, 4); ptr += 4;
6006                 memcpy(ptr, &param, 4); ptr += 4;
6007
6008         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6009         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6010
6011 }
6012
6013 void glTexParameterxvOES_enc(void *self , GLenum target, GLenum pname, const GLfixed* params)
6014 {
6015
6016         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6017         IOStream *stream = ctx->m_stream;
6018         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6019         bool useChecksum = checksumCalculator->getVersion() > 0;
6020
6021         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
6022          unsigned char *ptr;
6023          unsigned char *buf;
6024          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
6025          const size_t checksumSize = checksumCalculator->checksumByteSize();
6026          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6027         buf = stream->alloc(totalSize);
6028         ptr = buf;
6029         int tmp = OP_glTexParameterxvOES;memcpy(ptr, &tmp, 4); ptr += 4;
6030         memcpy(ptr, &totalSize, 4);  ptr += 4;
6031
6032                 memcpy(ptr, &target, 4); ptr += 4;
6033                 memcpy(ptr, &pname, 4); ptr += 4;
6034         *(unsigned int *)(ptr) = __size_params; ptr += 4;
6035         memcpy(ptr, params, __size_params);ptr += __size_params;
6036
6037         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6038         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6039
6040 }
6041
6042 void glTranslatexOES_enc(void *self , GLfixed x, GLfixed y, GLfixed z)
6043 {
6044
6045         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6046         IOStream *stream = ctx->m_stream;
6047         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6048         bool useChecksum = checksumCalculator->getVersion() > 0;
6049
6050          unsigned char *ptr;
6051          unsigned char *buf;
6052          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
6053          const size_t checksumSize = checksumCalculator->checksumByteSize();
6054          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6055         buf = stream->alloc(totalSize);
6056         ptr = buf;
6057         int tmp = OP_glTranslatexOES;memcpy(ptr, &tmp, 4); ptr += 4;
6058         memcpy(ptr, &totalSize, 4);  ptr += 4;
6059
6060                 memcpy(ptr, &x, 4); ptr += 4;
6061                 memcpy(ptr, &y, 4); ptr += 4;
6062                 memcpy(ptr, &z, 4); ptr += 4;
6063
6064         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6065         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6066
6067 }
6068
6069 GLboolean glIsRenderbufferOES_enc(void *self , GLuint renderbuffer)
6070 {
6071
6072         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6073         IOStream *stream = ctx->m_stream;
6074         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6075         bool useChecksum = checksumCalculator->getVersion() > 0;
6076
6077          unsigned char *ptr;
6078          unsigned char *buf;
6079          const size_t sizeWithoutChecksum = 8 + 4;
6080          const size_t checksumSize = checksumCalculator->checksumByteSize();
6081          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6082         buf = stream->alloc(totalSize);
6083         ptr = buf;
6084         int tmp = OP_glIsRenderbufferOES;memcpy(ptr, &tmp, 4); ptr += 4;
6085         memcpy(ptr, &totalSize, 4);  ptr += 4;
6086
6087                 memcpy(ptr, &renderbuffer, 4); ptr += 4;
6088
6089         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6090         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6091
6092
6093         GLboolean retval;
6094         stream->readback(&retval, 1);
6095         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
6096         if (useChecksum) {
6097                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
6098                 stream->readback(checksumBuf.get(), checksumSize);
6099                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
6100                         ALOGE("glIsRenderbufferOES: GL communication error, please report this issue to b.android.com.\n");
6101                         abort();
6102                 }
6103         }
6104         return retval;
6105 }
6106
6107 void glBindRenderbufferOES_enc(void *self , GLenum target, GLuint renderbuffer)
6108 {
6109
6110         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6111         IOStream *stream = ctx->m_stream;
6112         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6113         bool useChecksum = checksumCalculator->getVersion() > 0;
6114
6115          unsigned char *ptr;
6116          unsigned char *buf;
6117          const size_t sizeWithoutChecksum = 8 + 4 + 4;
6118          const size_t checksumSize = checksumCalculator->checksumByteSize();
6119          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6120         buf = stream->alloc(totalSize);
6121         ptr = buf;
6122         int tmp = OP_glBindRenderbufferOES;memcpy(ptr, &tmp, 4); ptr += 4;
6123         memcpy(ptr, &totalSize, 4);  ptr += 4;
6124
6125                 memcpy(ptr, &target, 4); ptr += 4;
6126                 memcpy(ptr, &renderbuffer, 4); ptr += 4;
6127
6128         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6129         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6130
6131 }
6132
6133 void glDeleteRenderbuffersOES_enc(void *self , GLsizei n, const GLuint* renderbuffers)
6134 {
6135
6136         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6137         IOStream *stream = ctx->m_stream;
6138         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6139         bool useChecksum = checksumCalculator->getVersion() > 0;
6140
6141         const unsigned int __size_renderbuffers =  (n * sizeof(GLuint));
6142          unsigned char *ptr;
6143          unsigned char *buf;
6144          const size_t sizeWithoutChecksum = 8 + 4 + __size_renderbuffers + 1*4;
6145          const size_t checksumSize = checksumCalculator->checksumByteSize();
6146          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6147         buf = stream->alloc(totalSize);
6148         ptr = buf;
6149         int tmp = OP_glDeleteRenderbuffersOES;memcpy(ptr, &tmp, 4); ptr += 4;
6150         memcpy(ptr, &totalSize, 4);  ptr += 4;
6151
6152                 memcpy(ptr, &n, 4); ptr += 4;
6153         *(unsigned int *)(ptr) = __size_renderbuffers; ptr += 4;
6154         memcpy(ptr, renderbuffers, __size_renderbuffers);ptr += __size_renderbuffers;
6155
6156         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6157         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6158
6159 }
6160
6161 void glGenRenderbuffersOES_enc(void *self , GLsizei n, GLuint* renderbuffers)
6162 {
6163
6164         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6165         IOStream *stream = ctx->m_stream;
6166         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6167         bool useChecksum = checksumCalculator->getVersion() > 0;
6168
6169         const unsigned int __size_renderbuffers =  (n * sizeof(GLuint));
6170          unsigned char *ptr;
6171          unsigned char *buf;
6172          const size_t sizeWithoutChecksum = 8 + 4 + __size_renderbuffers + 1*4;
6173          const size_t checksumSize = checksumCalculator->checksumByteSize();
6174          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6175         buf = stream->alloc(totalSize);
6176         ptr = buf;
6177         int tmp = OP_glGenRenderbuffersOES;memcpy(ptr, &tmp, 4); ptr += 4;
6178         memcpy(ptr, &totalSize, 4);  ptr += 4;
6179
6180                 memcpy(ptr, &n, 4); ptr += 4;
6181         *(unsigned int *)(ptr) = __size_renderbuffers; ptr += 4;
6182
6183         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6184         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6185
6186         stream->readback(renderbuffers, __size_renderbuffers);
6187         if (useChecksum) checksumCalculator->addBuffer(renderbuffers, __size_renderbuffers);
6188         if (useChecksum) {
6189                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
6190                 stream->readback(checksumBuf.get(), checksumSize);
6191                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
6192                         ALOGE("glGenRenderbuffersOES: GL communication error, please report this issue to b.android.com.\n");
6193                         abort();
6194                 }
6195         }
6196 }
6197
6198 void glRenderbufferStorageOES_enc(void *self , GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
6199 {
6200
6201         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6202         IOStream *stream = ctx->m_stream;
6203         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6204         bool useChecksum = checksumCalculator->getVersion() > 0;
6205
6206          unsigned char *ptr;
6207          unsigned char *buf;
6208          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 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_glRenderbufferStorageOES;memcpy(ptr, &tmp, 4); ptr += 4;
6214         memcpy(ptr, &totalSize, 4);  ptr += 4;
6215
6216                 memcpy(ptr, &target, 4); ptr += 4;
6217                 memcpy(ptr, &internalformat, 4); ptr += 4;
6218                 memcpy(ptr, &width, 4); ptr += 4;
6219                 memcpy(ptr, &height, 4); ptr += 4;
6220
6221         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6222         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6223
6224 }
6225
6226 void glGetRenderbufferParameterivOES_enc(void *self , GLenum target, GLenum pname, GLint* params)
6227 {
6228
6229         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6230         IOStream *stream = ctx->m_stream;
6231         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6232         bool useChecksum = checksumCalculator->getVersion() > 0;
6233
6234         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
6235          unsigned char *ptr;
6236          unsigned char *buf;
6237          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
6238          const size_t checksumSize = checksumCalculator->checksumByteSize();
6239          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6240         buf = stream->alloc(totalSize);
6241         ptr = buf;
6242         int tmp = OP_glGetRenderbufferParameterivOES;memcpy(ptr, &tmp, 4); ptr += 4;
6243         memcpy(ptr, &totalSize, 4);  ptr += 4;
6244
6245                 memcpy(ptr, &target, 4); ptr += 4;
6246                 memcpy(ptr, &pname, 4); ptr += 4;
6247         *(unsigned int *)(ptr) = __size_params; ptr += 4;
6248
6249         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6250         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6251
6252         stream->readback(params, __size_params);
6253         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
6254         if (useChecksum) {
6255                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
6256                 stream->readback(checksumBuf.get(), checksumSize);
6257                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
6258                         ALOGE("glGetRenderbufferParameterivOES: GL communication error, please report this issue to b.android.com.\n");
6259                         abort();
6260                 }
6261         }
6262 }
6263
6264 GLboolean glIsFramebufferOES_enc(void *self , GLuint framebuffer)
6265 {
6266
6267         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6268         IOStream *stream = ctx->m_stream;
6269         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6270         bool useChecksum = checksumCalculator->getVersion() > 0;
6271
6272          unsigned char *ptr;
6273          unsigned char *buf;
6274          const size_t sizeWithoutChecksum = 8 + 4;
6275          const size_t checksumSize = checksumCalculator->checksumByteSize();
6276          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6277         buf = stream->alloc(totalSize);
6278         ptr = buf;
6279         int tmp = OP_glIsFramebufferOES;memcpy(ptr, &tmp, 4); ptr += 4;
6280         memcpy(ptr, &totalSize, 4);  ptr += 4;
6281
6282                 memcpy(ptr, &framebuffer, 4); ptr += 4;
6283
6284         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6285         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6286
6287
6288         GLboolean retval;
6289         stream->readback(&retval, 1);
6290         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
6291         if (useChecksum) {
6292                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
6293                 stream->readback(checksumBuf.get(), checksumSize);
6294                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
6295                         ALOGE("glIsFramebufferOES: GL communication error, please report this issue to b.android.com.\n");
6296                         abort();
6297                 }
6298         }
6299         return retval;
6300 }
6301
6302 void glBindFramebufferOES_enc(void *self , GLenum target, GLuint framebuffer)
6303 {
6304
6305         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6306         IOStream *stream = ctx->m_stream;
6307         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6308         bool useChecksum = checksumCalculator->getVersion() > 0;
6309
6310          unsigned char *ptr;
6311          unsigned char *buf;
6312          const size_t sizeWithoutChecksum = 8 + 4 + 4;
6313          const size_t checksumSize = checksumCalculator->checksumByteSize();
6314          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6315         buf = stream->alloc(totalSize);
6316         ptr = buf;
6317         int tmp = OP_glBindFramebufferOES;memcpy(ptr, &tmp, 4); ptr += 4;
6318         memcpy(ptr, &totalSize, 4);  ptr += 4;
6319
6320                 memcpy(ptr, &target, 4); ptr += 4;
6321                 memcpy(ptr, &framebuffer, 4); ptr += 4;
6322
6323         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6324         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6325
6326 }
6327
6328 void glDeleteFramebuffersOES_enc(void *self , GLsizei n, const GLuint* framebuffers)
6329 {
6330
6331         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6332         IOStream *stream = ctx->m_stream;
6333         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6334         bool useChecksum = checksumCalculator->getVersion() > 0;
6335
6336         const unsigned int __size_framebuffers =  (n * sizeof(GLuint));
6337          unsigned char *ptr;
6338          unsigned char *buf;
6339          const size_t sizeWithoutChecksum = 8 + 4 + __size_framebuffers + 1*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_glDeleteFramebuffersOES;memcpy(ptr, &tmp, 4); ptr += 4;
6345         memcpy(ptr, &totalSize, 4);  ptr += 4;
6346
6347                 memcpy(ptr, &n, 4); ptr += 4;
6348         *(unsigned int *)(ptr) = __size_framebuffers; ptr += 4;
6349         memcpy(ptr, framebuffers, __size_framebuffers);ptr += __size_framebuffers;
6350
6351         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6352         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6353
6354 }
6355
6356 void glGenFramebuffersOES_enc(void *self , GLsizei n, GLuint* framebuffers)
6357 {
6358
6359         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6360         IOStream *stream = ctx->m_stream;
6361         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6362         bool useChecksum = checksumCalculator->getVersion() > 0;
6363
6364         const unsigned int __size_framebuffers =  (n * sizeof(GLuint));
6365          unsigned char *ptr;
6366          unsigned char *buf;
6367          const size_t sizeWithoutChecksum = 8 + 4 + __size_framebuffers + 1*4;
6368          const size_t checksumSize = checksumCalculator->checksumByteSize();
6369          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6370         buf = stream->alloc(totalSize);
6371         ptr = buf;
6372         int tmp = OP_glGenFramebuffersOES;memcpy(ptr, &tmp, 4); ptr += 4;
6373         memcpy(ptr, &totalSize, 4);  ptr += 4;
6374
6375                 memcpy(ptr, &n, 4); ptr += 4;
6376         *(unsigned int *)(ptr) = __size_framebuffers; ptr += 4;
6377
6378         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6379         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6380
6381         stream->readback(framebuffers, __size_framebuffers);
6382         if (useChecksum) checksumCalculator->addBuffer(framebuffers, __size_framebuffers);
6383         if (useChecksum) {
6384                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
6385                 stream->readback(checksumBuf.get(), checksumSize);
6386                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
6387                         ALOGE("glGenFramebuffersOES: GL communication error, please report this issue to b.android.com.\n");
6388                         abort();
6389                 }
6390         }
6391 }
6392
6393 GLenum glCheckFramebufferStatusOES_enc(void *self , GLenum target)
6394 {
6395
6396         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6397         IOStream *stream = ctx->m_stream;
6398         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6399         bool useChecksum = checksumCalculator->getVersion() > 0;
6400
6401          unsigned char *ptr;
6402          unsigned char *buf;
6403          const size_t sizeWithoutChecksum = 8 + 4;
6404          const size_t checksumSize = checksumCalculator->checksumByteSize();
6405          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6406         buf = stream->alloc(totalSize);
6407         ptr = buf;
6408         int tmp = OP_glCheckFramebufferStatusOES;memcpy(ptr, &tmp, 4); ptr += 4;
6409         memcpy(ptr, &totalSize, 4);  ptr += 4;
6410
6411                 memcpy(ptr, &target, 4); ptr += 4;
6412
6413         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6414         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6415
6416
6417         GLenum retval;
6418         stream->readback(&retval, 4);
6419         if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
6420         if (useChecksum) {
6421                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
6422                 stream->readback(checksumBuf.get(), checksumSize);
6423                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
6424                         ALOGE("glCheckFramebufferStatusOES: GL communication error, please report this issue to b.android.com.\n");
6425                         abort();
6426                 }
6427         }
6428         return retval;
6429 }
6430
6431 void glFramebufferRenderbufferOES_enc(void *self , GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
6432 {
6433
6434         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6435         IOStream *stream = ctx->m_stream;
6436         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6437         bool useChecksum = checksumCalculator->getVersion() > 0;
6438
6439          unsigned char *ptr;
6440          unsigned char *buf;
6441          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4;
6442          const size_t checksumSize = checksumCalculator->checksumByteSize();
6443          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6444         buf = stream->alloc(totalSize);
6445         ptr = buf;
6446         int tmp = OP_glFramebufferRenderbufferOES;memcpy(ptr, &tmp, 4); ptr += 4;
6447         memcpy(ptr, &totalSize, 4);  ptr += 4;
6448
6449                 memcpy(ptr, &target, 4); ptr += 4;
6450                 memcpy(ptr, &attachment, 4); ptr += 4;
6451                 memcpy(ptr, &renderbuffertarget, 4); ptr += 4;
6452                 memcpy(ptr, &renderbuffer, 4); ptr += 4;
6453
6454         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6455         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6456
6457 }
6458
6459 void glFramebufferTexture2DOES_enc(void *self , GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
6460 {
6461
6462         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6463         IOStream *stream = ctx->m_stream;
6464         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6465         bool useChecksum = checksumCalculator->getVersion() > 0;
6466
6467          unsigned char *ptr;
6468          unsigned char *buf;
6469          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
6470          const size_t checksumSize = checksumCalculator->checksumByteSize();
6471          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6472         buf = stream->alloc(totalSize);
6473         ptr = buf;
6474         int tmp = OP_glFramebufferTexture2DOES;memcpy(ptr, &tmp, 4); ptr += 4;
6475         memcpy(ptr, &totalSize, 4);  ptr += 4;
6476
6477                 memcpy(ptr, &target, 4); ptr += 4;
6478                 memcpy(ptr, &attachment, 4); ptr += 4;
6479                 memcpy(ptr, &textarget, 4); ptr += 4;
6480                 memcpy(ptr, &texture, 4); ptr += 4;
6481                 memcpy(ptr, &level, 4); ptr += 4;
6482
6483         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6484         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6485
6486 }
6487
6488 void glGetFramebufferAttachmentParameterivOES_enc(void *self , GLenum target, GLenum attachment, GLenum pname, GLint* params)
6489 {
6490
6491         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6492         IOStream *stream = ctx->m_stream;
6493         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6494         bool useChecksum = checksumCalculator->getVersion() > 0;
6495
6496         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
6497          unsigned char *ptr;
6498          unsigned char *buf;
6499          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + __size_params + 1*4;
6500          const size_t checksumSize = checksumCalculator->checksumByteSize();
6501          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6502         buf = stream->alloc(totalSize);
6503         ptr = buf;
6504         int tmp = OP_glGetFramebufferAttachmentParameterivOES;memcpy(ptr, &tmp, 4); ptr += 4;
6505         memcpy(ptr, &totalSize, 4);  ptr += 4;
6506
6507                 memcpy(ptr, &target, 4); ptr += 4;
6508                 memcpy(ptr, &attachment, 4); ptr += 4;
6509                 memcpy(ptr, &pname, 4); ptr += 4;
6510         *(unsigned int *)(ptr) = __size_params; ptr += 4;
6511
6512         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6513         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6514
6515         stream->readback(params, __size_params);
6516         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
6517         if (useChecksum) {
6518                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
6519                 stream->readback(checksumBuf.get(), checksumSize);
6520                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
6521                         ALOGE("glGetFramebufferAttachmentParameterivOES: GL communication error, please report this issue to b.android.com.\n");
6522                         abort();
6523                 }
6524         }
6525 }
6526
6527 void glGenerateMipmapOES_enc(void *self , GLenum target)
6528 {
6529
6530         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6531         IOStream *stream = ctx->m_stream;
6532         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6533         bool useChecksum = checksumCalculator->getVersion() > 0;
6534
6535          unsigned char *ptr;
6536          unsigned char *buf;
6537          const size_t sizeWithoutChecksum = 8 + 4;
6538          const size_t checksumSize = checksumCalculator->checksumByteSize();
6539          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6540         buf = stream->alloc(totalSize);
6541         ptr = buf;
6542         int tmp = OP_glGenerateMipmapOES;memcpy(ptr, &tmp, 4); ptr += 4;
6543         memcpy(ptr, &totalSize, 4);  ptr += 4;
6544
6545                 memcpy(ptr, &target, 4); ptr += 4;
6546
6547         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6548         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6549
6550 }
6551
6552 GLboolean glUnmapBufferOES_enc(void *self , GLenum target)
6553 {
6554
6555         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6556         IOStream *stream = ctx->m_stream;
6557         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6558         bool useChecksum = checksumCalculator->getVersion() > 0;
6559
6560          unsigned char *ptr;
6561          unsigned char *buf;
6562          const size_t sizeWithoutChecksum = 8 + 4;
6563          const size_t checksumSize = checksumCalculator->checksumByteSize();
6564          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6565         buf = stream->alloc(totalSize);
6566         ptr = buf;
6567         int tmp = OP_glUnmapBufferOES;memcpy(ptr, &tmp, 4); ptr += 4;
6568         memcpy(ptr, &totalSize, 4);  ptr += 4;
6569
6570                 memcpy(ptr, &target, 4); ptr += 4;
6571
6572         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6573         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6574
6575
6576         GLboolean retval;
6577         stream->readback(&retval, 1);
6578         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
6579         if (useChecksum) {
6580                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
6581                 stream->readback(checksumBuf.get(), checksumSize);
6582                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
6583                         ALOGE("glUnmapBufferOES: GL communication error, please report this issue to b.android.com.\n");
6584                         abort();
6585                 }
6586         }
6587         return retval;
6588 }
6589
6590 void glCurrentPaletteMatrixOES_enc(void *self , GLuint matrixpaletteindex)
6591 {
6592
6593         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6594         IOStream *stream = ctx->m_stream;
6595         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6596         bool useChecksum = checksumCalculator->getVersion() > 0;
6597
6598          unsigned char *ptr;
6599          unsigned char *buf;
6600          const size_t sizeWithoutChecksum = 8 + 4;
6601          const size_t checksumSize = checksumCalculator->checksumByteSize();
6602          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6603         buf = stream->alloc(totalSize);
6604         ptr = buf;
6605         int tmp = OP_glCurrentPaletteMatrixOES;memcpy(ptr, &tmp, 4); ptr += 4;
6606         memcpy(ptr, &totalSize, 4);  ptr += 4;
6607
6608                 memcpy(ptr, &matrixpaletteindex, 4); ptr += 4;
6609
6610         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6611         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6612
6613 }
6614
6615 void glLoadPaletteFromModelViewMatrixOES_enc(void *self )
6616 {
6617
6618         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6619         IOStream *stream = ctx->m_stream;
6620         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6621         bool useChecksum = checksumCalculator->getVersion() > 0;
6622
6623          unsigned char *ptr;
6624          unsigned char *buf;
6625          const size_t sizeWithoutChecksum = 8;
6626          const size_t checksumSize = checksumCalculator->checksumByteSize();
6627          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6628         buf = stream->alloc(totalSize);
6629         ptr = buf;
6630         int tmp = OP_glLoadPaletteFromModelViewMatrixOES;memcpy(ptr, &tmp, 4); ptr += 4;
6631         memcpy(ptr, &totalSize, 4);  ptr += 4;
6632
6633
6634         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6635         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6636
6637 }
6638
6639 GLbitfield glQueryMatrixxOES_enc(void *self , GLfixed* mantissa, GLint* exponent)
6640 {
6641
6642         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6643         IOStream *stream = ctx->m_stream;
6644         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6645         bool useChecksum = checksumCalculator->getVersion() > 0;
6646
6647         const unsigned int __size_mantissa =  (16 * sizeof(GLfixed));
6648         const unsigned int __size_exponent =  (16 * sizeof(GLfixed));
6649          unsigned char *ptr;
6650          unsigned char *buf;
6651          const size_t sizeWithoutChecksum = 8 + __size_mantissa + __size_exponent + 2*4;
6652          const size_t checksumSize = checksumCalculator->checksumByteSize();
6653          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6654         buf = stream->alloc(totalSize);
6655         ptr = buf;
6656         int tmp = OP_glQueryMatrixxOES;memcpy(ptr, &tmp, 4); ptr += 4;
6657         memcpy(ptr, &totalSize, 4);  ptr += 4;
6658
6659         *(unsigned int *)(ptr) = __size_mantissa; ptr += 4;
6660         *(unsigned int *)(ptr) = __size_exponent; ptr += 4;
6661
6662         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6663         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6664
6665         stream->readback(mantissa, __size_mantissa);
6666         if (useChecksum) checksumCalculator->addBuffer(mantissa, __size_mantissa);
6667         stream->readback(exponent, __size_exponent);
6668         if (useChecksum) checksumCalculator->addBuffer(exponent, __size_exponent);
6669
6670         GLbitfield retval;
6671         stream->readback(&retval, 4);
6672         if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
6673         if (useChecksum) {
6674                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
6675                 stream->readback(checksumBuf.get(), checksumSize);
6676                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
6677                         ALOGE("glQueryMatrixxOES: GL communication error, please report this issue to b.android.com.\n");
6678                         abort();
6679                 }
6680         }
6681         return retval;
6682 }
6683
6684 void glDepthRangefOES_enc(void *self , GLclampf zNear, GLclampf zFar)
6685 {
6686
6687         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6688         IOStream *stream = ctx->m_stream;
6689         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6690         bool useChecksum = checksumCalculator->getVersion() > 0;
6691
6692          unsigned char *ptr;
6693          unsigned char *buf;
6694          const size_t sizeWithoutChecksum = 8 + 4 + 4;
6695          const size_t checksumSize = checksumCalculator->checksumByteSize();
6696          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6697         buf = stream->alloc(totalSize);
6698         ptr = buf;
6699         int tmp = OP_glDepthRangefOES;memcpy(ptr, &tmp, 4); ptr += 4;
6700         memcpy(ptr, &totalSize, 4);  ptr += 4;
6701
6702                 memcpy(ptr, &zNear, 4); ptr += 4;
6703                 memcpy(ptr, &zFar, 4); ptr += 4;
6704
6705         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6706         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6707
6708 }
6709
6710 void glFrustumfOES_enc(void *self , GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
6711 {
6712
6713         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6714         IOStream *stream = ctx->m_stream;
6715         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6716         bool useChecksum = checksumCalculator->getVersion() > 0;
6717
6718          unsigned char *ptr;
6719          unsigned char *buf;
6720          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4;
6721          const size_t checksumSize = checksumCalculator->checksumByteSize();
6722          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6723         buf = stream->alloc(totalSize);
6724         ptr = buf;
6725         int tmp = OP_glFrustumfOES;memcpy(ptr, &tmp, 4); ptr += 4;
6726         memcpy(ptr, &totalSize, 4);  ptr += 4;
6727
6728                 memcpy(ptr, &left, 4); ptr += 4;
6729                 memcpy(ptr, &right, 4); ptr += 4;
6730                 memcpy(ptr, &bottom, 4); ptr += 4;
6731                 memcpy(ptr, &top, 4); ptr += 4;
6732                 memcpy(ptr, &zNear, 4); ptr += 4;
6733                 memcpy(ptr, &zFar, 4); ptr += 4;
6734
6735         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6736         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6737
6738 }
6739
6740 void glOrthofOES_enc(void *self , GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
6741 {
6742
6743         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6744         IOStream *stream = ctx->m_stream;
6745         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6746         bool useChecksum = checksumCalculator->getVersion() > 0;
6747
6748          unsigned char *ptr;
6749          unsigned char *buf;
6750          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4;
6751          const size_t checksumSize = checksumCalculator->checksumByteSize();
6752          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6753         buf = stream->alloc(totalSize);
6754         ptr = buf;
6755         int tmp = OP_glOrthofOES;memcpy(ptr, &tmp, 4); ptr += 4;
6756         memcpy(ptr, &totalSize, 4);  ptr += 4;
6757
6758                 memcpy(ptr, &left, 4); ptr += 4;
6759                 memcpy(ptr, &right, 4); ptr += 4;
6760                 memcpy(ptr, &bottom, 4); ptr += 4;
6761                 memcpy(ptr, &top, 4); ptr += 4;
6762                 memcpy(ptr, &zNear, 4); ptr += 4;
6763                 memcpy(ptr, &zFar, 4); ptr += 4;
6764
6765         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6766         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6767
6768 }
6769
6770 void glClipPlanefOES_enc(void *self , GLenum plane, const GLfloat* equation)
6771 {
6772
6773         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6774         IOStream *stream = ctx->m_stream;
6775         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6776         bool useChecksum = checksumCalculator->getVersion() > 0;
6777
6778         const unsigned int __size_equation =  (4 * sizeof(GLfloat));
6779          unsigned char *ptr;
6780          unsigned char *buf;
6781          const size_t sizeWithoutChecksum = 8 + 4 + __size_equation + 1*4;
6782          const size_t checksumSize = checksumCalculator->checksumByteSize();
6783          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6784         buf = stream->alloc(totalSize);
6785         ptr = buf;
6786         int tmp = OP_glClipPlanefOES;memcpy(ptr, &tmp, 4); ptr += 4;
6787         memcpy(ptr, &totalSize, 4);  ptr += 4;
6788
6789                 memcpy(ptr, &plane, 4); ptr += 4;
6790         *(unsigned int *)(ptr) = __size_equation; ptr += 4;
6791         memcpy(ptr, equation, __size_equation);ptr += __size_equation;
6792
6793         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6794         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6795
6796 }
6797
6798 void glClipPlanefIMG_enc(void *self , GLenum plane, const GLfloat* equation)
6799 {
6800
6801         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6802         IOStream *stream = ctx->m_stream;
6803         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6804         bool useChecksum = checksumCalculator->getVersion() > 0;
6805
6806         const unsigned int __size_equation =  (4 * sizeof(GLfloat));
6807          unsigned char *ptr;
6808          unsigned char *buf;
6809          const size_t sizeWithoutChecksum = 8 + 4 + __size_equation + 1*4;
6810          const size_t checksumSize = checksumCalculator->checksumByteSize();
6811          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6812         buf = stream->alloc(totalSize);
6813         ptr = buf;
6814         int tmp = OP_glClipPlanefIMG;memcpy(ptr, &tmp, 4); ptr += 4;
6815         memcpy(ptr, &totalSize, 4);  ptr += 4;
6816
6817                 memcpy(ptr, &plane, 4); ptr += 4;
6818         *(unsigned int *)(ptr) = __size_equation; ptr += 4;
6819         memcpy(ptr, equation, __size_equation);ptr += __size_equation;
6820
6821         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6822         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6823
6824 }
6825
6826 void glGetClipPlanefOES_enc(void *self , GLenum pname, GLfloat* eqn)
6827 {
6828
6829         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6830         IOStream *stream = ctx->m_stream;
6831         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6832         bool useChecksum = checksumCalculator->getVersion() > 0;
6833
6834         const unsigned int __size_eqn =  (4 * sizeof(GLfloat));
6835          unsigned char *ptr;
6836          unsigned char *buf;
6837          const size_t sizeWithoutChecksum = 8 + 4 + __size_eqn + 1*4;
6838          const size_t checksumSize = checksumCalculator->checksumByteSize();
6839          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6840         buf = stream->alloc(totalSize);
6841         ptr = buf;
6842         int tmp = OP_glGetClipPlanefOES;memcpy(ptr, &tmp, 4); ptr += 4;
6843         memcpy(ptr, &totalSize, 4);  ptr += 4;
6844
6845                 memcpy(ptr, &pname, 4); ptr += 4;
6846         *(unsigned int *)(ptr) = __size_eqn; ptr += 4;
6847
6848         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6849         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6850
6851         stream->readback(eqn, __size_eqn);
6852         if (useChecksum) checksumCalculator->addBuffer(eqn, __size_eqn);
6853         if (useChecksum) {
6854                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
6855                 stream->readback(checksumBuf.get(), checksumSize);
6856                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
6857                         ALOGE("glGetClipPlanefOES: GL communication error, please report this issue to b.android.com.\n");
6858                         abort();
6859                 }
6860         }
6861 }
6862
6863 void glClearDepthfOES_enc(void *self , GLclampf depth)
6864 {
6865
6866         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6867         IOStream *stream = ctx->m_stream;
6868         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6869         bool useChecksum = checksumCalculator->getVersion() > 0;
6870
6871          unsigned char *ptr;
6872          unsigned char *buf;
6873          const size_t sizeWithoutChecksum = 8 + 4;
6874          const size_t checksumSize = checksumCalculator->checksumByteSize();
6875          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6876         buf = stream->alloc(totalSize);
6877         ptr = buf;
6878         int tmp = OP_glClearDepthfOES;memcpy(ptr, &tmp, 4); ptr += 4;
6879         memcpy(ptr, &totalSize, 4);  ptr += 4;
6880
6881                 memcpy(ptr, &depth, 4); ptr += 4;
6882
6883         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6884         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6885
6886 }
6887
6888 void glTexGenfOES_enc(void *self , GLenum coord, GLenum pname, GLfloat param)
6889 {
6890
6891         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6892         IOStream *stream = ctx->m_stream;
6893         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6894         bool useChecksum = checksumCalculator->getVersion() > 0;
6895
6896          unsigned char *ptr;
6897          unsigned char *buf;
6898          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
6899          const size_t checksumSize = checksumCalculator->checksumByteSize();
6900          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6901         buf = stream->alloc(totalSize);
6902         ptr = buf;
6903         int tmp = OP_glTexGenfOES;memcpy(ptr, &tmp, 4); ptr += 4;
6904         memcpy(ptr, &totalSize, 4);  ptr += 4;
6905
6906                 memcpy(ptr, &coord, 4); ptr += 4;
6907                 memcpy(ptr, &pname, 4); ptr += 4;
6908                 memcpy(ptr, &param, 4); ptr += 4;
6909
6910         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6911         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6912
6913 }
6914
6915 void glTexGenfvOES_enc(void *self , GLenum coord, GLenum pname, const GLfloat* params)
6916 {
6917
6918         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6919         IOStream *stream = ctx->m_stream;
6920         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6921         bool useChecksum = checksumCalculator->getVersion() > 0;
6922
6923         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
6924          unsigned char *ptr;
6925          unsigned char *buf;
6926          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
6927          const size_t checksumSize = checksumCalculator->checksumByteSize();
6928          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6929         buf = stream->alloc(totalSize);
6930         ptr = buf;
6931         int tmp = OP_glTexGenfvOES;memcpy(ptr, &tmp, 4); ptr += 4;
6932         memcpy(ptr, &totalSize, 4);  ptr += 4;
6933
6934                 memcpy(ptr, &coord, 4); ptr += 4;
6935                 memcpy(ptr, &pname, 4); ptr += 4;
6936         *(unsigned int *)(ptr) = __size_params; ptr += 4;
6937         memcpy(ptr, params, __size_params);ptr += __size_params;
6938
6939         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6940         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6941
6942 }
6943
6944 void glTexGeniOES_enc(void *self , GLenum coord, GLenum pname, GLint param)
6945 {
6946
6947         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6948         IOStream *stream = ctx->m_stream;
6949         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6950         bool useChecksum = checksumCalculator->getVersion() > 0;
6951
6952          unsigned char *ptr;
6953          unsigned char *buf;
6954          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
6955          const size_t checksumSize = checksumCalculator->checksumByteSize();
6956          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6957         buf = stream->alloc(totalSize);
6958         ptr = buf;
6959         int tmp = OP_glTexGeniOES;memcpy(ptr, &tmp, 4); ptr += 4;
6960         memcpy(ptr, &totalSize, 4);  ptr += 4;
6961
6962                 memcpy(ptr, &coord, 4); ptr += 4;
6963                 memcpy(ptr, &pname, 4); ptr += 4;
6964                 memcpy(ptr, &param, 4); ptr += 4;
6965
6966         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6967         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6968
6969 }
6970
6971 void glTexGenivOES_enc(void *self , GLenum coord, GLenum pname, const GLint* params)
6972 {
6973
6974         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
6975         IOStream *stream = ctx->m_stream;
6976         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
6977         bool useChecksum = checksumCalculator->getVersion() > 0;
6978
6979         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
6980          unsigned char *ptr;
6981          unsigned char *buf;
6982          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
6983          const size_t checksumSize = checksumCalculator->checksumByteSize();
6984          const size_t totalSize = sizeWithoutChecksum + checksumSize;
6985         buf = stream->alloc(totalSize);
6986         ptr = buf;
6987         int tmp = OP_glTexGenivOES;memcpy(ptr, &tmp, 4); ptr += 4;
6988         memcpy(ptr, &totalSize, 4);  ptr += 4;
6989
6990                 memcpy(ptr, &coord, 4); ptr += 4;
6991                 memcpy(ptr, &pname, 4); ptr += 4;
6992         *(unsigned int *)(ptr) = __size_params; ptr += 4;
6993         memcpy(ptr, params, __size_params);ptr += __size_params;
6994
6995         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
6996         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
6997
6998 }
6999
7000 void glTexGenxOES_enc(void *self , GLenum coord, GLenum pname, GLfixed param)
7001 {
7002
7003         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7004         IOStream *stream = ctx->m_stream;
7005         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7006         bool useChecksum = checksumCalculator->getVersion() > 0;
7007
7008          unsigned char *ptr;
7009          unsigned char *buf;
7010          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
7011          const size_t checksumSize = checksumCalculator->checksumByteSize();
7012          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7013         buf = stream->alloc(totalSize);
7014         ptr = buf;
7015         int tmp = OP_glTexGenxOES;memcpy(ptr, &tmp, 4); ptr += 4;
7016         memcpy(ptr, &totalSize, 4);  ptr += 4;
7017
7018                 memcpy(ptr, &coord, 4); ptr += 4;
7019                 memcpy(ptr, &pname, 4); ptr += 4;
7020                 memcpy(ptr, &param, 4); ptr += 4;
7021
7022         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7023         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7024
7025 }
7026
7027 void glTexGenxvOES_enc(void *self , GLenum coord, GLenum pname, const GLfixed* params)
7028 {
7029
7030         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7031         IOStream *stream = ctx->m_stream;
7032         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7033         bool useChecksum = checksumCalculator->getVersion() > 0;
7034
7035         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
7036          unsigned char *ptr;
7037          unsigned char *buf;
7038          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
7039          const size_t checksumSize = checksumCalculator->checksumByteSize();
7040          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7041         buf = stream->alloc(totalSize);
7042         ptr = buf;
7043         int tmp = OP_glTexGenxvOES;memcpy(ptr, &tmp, 4); ptr += 4;
7044         memcpy(ptr, &totalSize, 4);  ptr += 4;
7045
7046                 memcpy(ptr, &coord, 4); ptr += 4;
7047                 memcpy(ptr, &pname, 4); ptr += 4;
7048         *(unsigned int *)(ptr) = __size_params; ptr += 4;
7049         memcpy(ptr, params, __size_params);ptr += __size_params;
7050
7051         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7052         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7053
7054 }
7055
7056 void glGetTexGenfvOES_enc(void *self , GLenum coord, GLenum pname, GLfloat* params)
7057 {
7058
7059         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7060         IOStream *stream = ctx->m_stream;
7061         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7062         bool useChecksum = checksumCalculator->getVersion() > 0;
7063
7064         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfloat));
7065          unsigned char *ptr;
7066          unsigned char *buf;
7067          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
7068          const size_t checksumSize = checksumCalculator->checksumByteSize();
7069          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7070         buf = stream->alloc(totalSize);
7071         ptr = buf;
7072         int tmp = OP_glGetTexGenfvOES;memcpy(ptr, &tmp, 4); ptr += 4;
7073         memcpy(ptr, &totalSize, 4);  ptr += 4;
7074
7075                 memcpy(ptr, &coord, 4); ptr += 4;
7076                 memcpy(ptr, &pname, 4); ptr += 4;
7077         *(unsigned int *)(ptr) = __size_params; ptr += 4;
7078         memcpy(ptr, params, __size_params);ptr += __size_params;
7079
7080         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7081         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7082
7083 }
7084
7085 void glGetTexGenivOES_enc(void *self , GLenum coord, GLenum pname, GLint* params)
7086 {
7087
7088         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7089         IOStream *stream = ctx->m_stream;
7090         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7091         bool useChecksum = checksumCalculator->getVersion() > 0;
7092
7093         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
7094          unsigned char *ptr;
7095          unsigned char *buf;
7096          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
7097          const size_t checksumSize = checksumCalculator->checksumByteSize();
7098          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7099         buf = stream->alloc(totalSize);
7100         ptr = buf;
7101         int tmp = OP_glGetTexGenivOES;memcpy(ptr, &tmp, 4); ptr += 4;
7102         memcpy(ptr, &totalSize, 4);  ptr += 4;
7103
7104                 memcpy(ptr, &coord, 4); ptr += 4;
7105                 memcpy(ptr, &pname, 4); ptr += 4;
7106         *(unsigned int *)(ptr) = __size_params; ptr += 4;
7107         memcpy(ptr, params, __size_params);ptr += __size_params;
7108
7109         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7110         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7111
7112 }
7113
7114 void glGetTexGenxvOES_enc(void *self , GLenum coord, GLenum pname, GLfixed* params)
7115 {
7116
7117         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7118         IOStream *stream = ctx->m_stream;
7119         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7120         bool useChecksum = checksumCalculator->getVersion() > 0;
7121
7122         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLfixed));
7123          unsigned char *ptr;
7124          unsigned char *buf;
7125          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
7126          const size_t checksumSize = checksumCalculator->checksumByteSize();
7127          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7128         buf = stream->alloc(totalSize);
7129         ptr = buf;
7130         int tmp = OP_glGetTexGenxvOES;memcpy(ptr, &tmp, 4); ptr += 4;
7131         memcpy(ptr, &totalSize, 4);  ptr += 4;
7132
7133                 memcpy(ptr, &coord, 4); ptr += 4;
7134                 memcpy(ptr, &pname, 4); ptr += 4;
7135         *(unsigned int *)(ptr) = __size_params; ptr += 4;
7136         memcpy(ptr, params, __size_params);ptr += __size_params;
7137
7138         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7139         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7140
7141 }
7142
7143 void glBindVertexArrayOES_enc(void *self , GLuint array)
7144 {
7145
7146         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7147         IOStream *stream = ctx->m_stream;
7148         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7149         bool useChecksum = checksumCalculator->getVersion() > 0;
7150
7151          unsigned char *ptr;
7152          unsigned char *buf;
7153          const size_t sizeWithoutChecksum = 8 + 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_glBindVertexArrayOES;memcpy(ptr, &tmp, 4); ptr += 4;
7159         memcpy(ptr, &totalSize, 4);  ptr += 4;
7160
7161                 memcpy(ptr, &array, 4); ptr += 4;
7162
7163         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7164         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7165
7166 }
7167
7168 void glDeleteVertexArraysOES_enc(void *self , GLsizei n, const GLuint* arrays)
7169 {
7170
7171         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7172         IOStream *stream = ctx->m_stream;
7173         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7174         bool useChecksum = checksumCalculator->getVersion() > 0;
7175
7176         const unsigned int __size_arrays =  (n * sizeof(GLuint));
7177          unsigned char *ptr;
7178          unsigned char *buf;
7179          const size_t sizeWithoutChecksum = 8 + 4 + __size_arrays + 1*4;
7180          const size_t checksumSize = checksumCalculator->checksumByteSize();
7181          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7182         buf = stream->alloc(totalSize);
7183         ptr = buf;
7184         int tmp = OP_glDeleteVertexArraysOES;memcpy(ptr, &tmp, 4); ptr += 4;
7185         memcpy(ptr, &totalSize, 4);  ptr += 4;
7186
7187                 memcpy(ptr, &n, 4); ptr += 4;
7188         *(unsigned int *)(ptr) = __size_arrays; ptr += 4;
7189         memcpy(ptr, arrays, __size_arrays);ptr += __size_arrays;
7190
7191         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7192         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7193
7194 }
7195
7196 void glGenVertexArraysOES_enc(void *self , GLsizei n, GLuint* arrays)
7197 {
7198
7199         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7200         IOStream *stream = ctx->m_stream;
7201         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7202         bool useChecksum = checksumCalculator->getVersion() > 0;
7203
7204         const unsigned int __size_arrays =  (n * sizeof(GLuint));
7205          unsigned char *ptr;
7206          unsigned char *buf;
7207          const size_t sizeWithoutChecksum = 8 + 4 + __size_arrays + 1*4;
7208          const size_t checksumSize = checksumCalculator->checksumByteSize();
7209          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7210         buf = stream->alloc(totalSize);
7211         ptr = buf;
7212         int tmp = OP_glGenVertexArraysOES;memcpy(ptr, &tmp, 4); ptr += 4;
7213         memcpy(ptr, &totalSize, 4);  ptr += 4;
7214
7215                 memcpy(ptr, &n, 4); ptr += 4;
7216         *(unsigned int *)(ptr) = __size_arrays; ptr += 4;
7217
7218         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7219         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7220
7221         stream->readback(arrays, __size_arrays);
7222         if (useChecksum) checksumCalculator->addBuffer(arrays, __size_arrays);
7223         if (useChecksum) {
7224                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
7225                 stream->readback(checksumBuf.get(), checksumSize);
7226                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
7227                         ALOGE("glGenVertexArraysOES: GL communication error, please report this issue to b.android.com.\n");
7228                         abort();
7229                 }
7230         }
7231 }
7232
7233 GLboolean glIsVertexArrayOES_enc(void *self , GLuint array)
7234 {
7235
7236         gl_encoder_context_t *ctx = (gl_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;
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_glIsVertexArrayOES;memcpy(ptr, &tmp, 4); ptr += 4;
7249         memcpy(ptr, &totalSize, 4);  ptr += 4;
7250
7251                 memcpy(ptr, &array, 4); ptr += 4;
7252
7253         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7254         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7255
7256
7257         GLboolean retval;
7258         stream->readback(&retval, 1);
7259         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
7260         if (useChecksum) {
7261                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
7262                 stream->readback(checksumBuf.get(), checksumSize);
7263                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
7264                         ALOGE("glIsVertexArrayOES: GL communication error, please report this issue to b.android.com.\n");
7265                         abort();
7266                 }
7267         }
7268         return retval;
7269 }
7270
7271 void glDiscardFramebufferEXT_enc(void *self , GLenum target, GLsizei numAttachments, const GLenum* attachments)
7272 {
7273
7274         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7275         IOStream *stream = ctx->m_stream;
7276         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7277         bool useChecksum = checksumCalculator->getVersion() > 0;
7278
7279         const unsigned int __size_attachments =  (numAttachments * sizeof(const GLenum));
7280          unsigned char *ptr;
7281          unsigned char *buf;
7282          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_attachments + 1*4;
7283          const size_t checksumSize = checksumCalculator->checksumByteSize();
7284          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7285         buf = stream->alloc(totalSize);
7286         ptr = buf;
7287         int tmp = OP_glDiscardFramebufferEXT;memcpy(ptr, &tmp, 4); ptr += 4;
7288         memcpy(ptr, &totalSize, 4);  ptr += 4;
7289
7290                 memcpy(ptr, &target, 4); ptr += 4;
7291                 memcpy(ptr, &numAttachments, 4); ptr += 4;
7292         *(unsigned int *)(ptr) = __size_attachments; ptr += 4;
7293         memcpy(ptr, attachments, __size_attachments);ptr += __size_attachments;
7294
7295         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7296         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7297
7298 }
7299
7300 void glRenderbufferStorageMultisampleIMG_enc(void *self , GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
7301 {
7302
7303         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7304         IOStream *stream = ctx->m_stream;
7305         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7306         bool useChecksum = checksumCalculator->getVersion() > 0;
7307
7308          unsigned char *ptr;
7309          unsigned char *buf;
7310          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
7311          const size_t checksumSize = checksumCalculator->checksumByteSize();
7312          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7313         buf = stream->alloc(totalSize);
7314         ptr = buf;
7315         int tmp = OP_glRenderbufferStorageMultisampleIMG;memcpy(ptr, &tmp, 4); ptr += 4;
7316         memcpy(ptr, &totalSize, 4);  ptr += 4;
7317
7318                 memcpy(ptr, &target, 4); ptr += 4;
7319                 memcpy(ptr, &samples, 4); ptr += 4;
7320                 memcpy(ptr, &internalformat, 4); ptr += 4;
7321                 memcpy(ptr, &width, 4); ptr += 4;
7322                 memcpy(ptr, &height, 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 glFramebufferTexture2DMultisampleIMG_enc(void *self , GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
7330 {
7331
7332         gl_encoder_context_t *ctx = (gl_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 + 4 + 4 + 4 + 4 + 4 + 4;
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_glFramebufferTexture2DMultisampleIMG;memcpy(ptr, &tmp, 4); ptr += 4;
7345         memcpy(ptr, &totalSize, 4);  ptr += 4;
7346
7347                 memcpy(ptr, &target, 4); ptr += 4;
7348                 memcpy(ptr, &attachment, 4); ptr += 4;
7349                 memcpy(ptr, &textarget, 4); ptr += 4;
7350                 memcpy(ptr, &texture, 4); ptr += 4;
7351                 memcpy(ptr, &level, 4); ptr += 4;
7352                 memcpy(ptr, &samples, 4); ptr += 4;
7353
7354         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7355         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7356
7357 }
7358
7359 void glDeleteFencesNV_enc(void *self , GLsizei n, const GLuint* fences)
7360 {
7361
7362         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7363         IOStream *stream = ctx->m_stream;
7364         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7365         bool useChecksum = checksumCalculator->getVersion() > 0;
7366
7367         const unsigned int __size_fences =  (n * sizeof(GLuint));
7368          unsigned char *ptr;
7369          unsigned char *buf;
7370          const size_t sizeWithoutChecksum = 8 + 4 + __size_fences + 1*4;
7371          const size_t checksumSize = checksumCalculator->checksumByteSize();
7372          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7373         buf = stream->alloc(totalSize);
7374         ptr = buf;
7375         int tmp = OP_glDeleteFencesNV;memcpy(ptr, &tmp, 4); ptr += 4;
7376         memcpy(ptr, &totalSize, 4);  ptr += 4;
7377
7378                 memcpy(ptr, &n, 4); ptr += 4;
7379         *(unsigned int *)(ptr) = __size_fences; ptr += 4;
7380         memcpy(ptr, fences, __size_fences);ptr += __size_fences;
7381
7382         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7383         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7384
7385 }
7386
7387 void glGenFencesNV_enc(void *self , GLsizei n, GLuint* fences)
7388 {
7389
7390         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7391         IOStream *stream = ctx->m_stream;
7392         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7393         bool useChecksum = checksumCalculator->getVersion() > 0;
7394
7395         const unsigned int __size_fences =  (n * sizeof(GLuint));
7396          unsigned char *ptr;
7397          unsigned char *buf;
7398          const size_t sizeWithoutChecksum = 8 + 4 + __size_fences + 1*4;
7399          const size_t checksumSize = checksumCalculator->checksumByteSize();
7400          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7401         buf = stream->alloc(totalSize);
7402         ptr = buf;
7403         int tmp = OP_glGenFencesNV;memcpy(ptr, &tmp, 4); ptr += 4;
7404         memcpy(ptr, &totalSize, 4);  ptr += 4;
7405
7406                 memcpy(ptr, &n, 4); ptr += 4;
7407         *(unsigned int *)(ptr) = __size_fences; ptr += 4;
7408         memcpy(ptr, fences, __size_fences);ptr += __size_fences;
7409
7410         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7411         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7412
7413 }
7414
7415 GLboolean glIsFenceNV_enc(void *self , GLuint fence)
7416 {
7417
7418         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7419         IOStream *stream = ctx->m_stream;
7420         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7421         bool useChecksum = checksumCalculator->getVersion() > 0;
7422
7423          unsigned char *ptr;
7424          unsigned char *buf;
7425          const size_t sizeWithoutChecksum = 8 + 4;
7426          const size_t checksumSize = checksumCalculator->checksumByteSize();
7427          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7428         buf = stream->alloc(totalSize);
7429         ptr = buf;
7430         int tmp = OP_glIsFenceNV;memcpy(ptr, &tmp, 4); ptr += 4;
7431         memcpy(ptr, &totalSize, 4);  ptr += 4;
7432
7433                 memcpy(ptr, &fence, 4); ptr += 4;
7434
7435         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7436         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7437
7438
7439         GLboolean retval;
7440         stream->readback(&retval, 1);
7441         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
7442         if (useChecksum) {
7443                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
7444                 stream->readback(checksumBuf.get(), checksumSize);
7445                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
7446                         ALOGE("glIsFenceNV: GL communication error, please report this issue to b.android.com.\n");
7447                         abort();
7448                 }
7449         }
7450         return retval;
7451 }
7452
7453 GLboolean glTestFenceNV_enc(void *self , GLuint fence)
7454 {
7455
7456         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7457         IOStream *stream = ctx->m_stream;
7458         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7459         bool useChecksum = checksumCalculator->getVersion() > 0;
7460
7461          unsigned char *ptr;
7462          unsigned char *buf;
7463          const size_t sizeWithoutChecksum = 8 + 4;
7464          const size_t checksumSize = checksumCalculator->checksumByteSize();
7465          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7466         buf = stream->alloc(totalSize);
7467         ptr = buf;
7468         int tmp = OP_glTestFenceNV;memcpy(ptr, &tmp, 4); ptr += 4;
7469         memcpy(ptr, &totalSize, 4);  ptr += 4;
7470
7471                 memcpy(ptr, &fence, 4); ptr += 4;
7472
7473         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7474         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7475
7476
7477         GLboolean retval;
7478         stream->readback(&retval, 1);
7479         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
7480         if (useChecksum) {
7481                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
7482                 stream->readback(checksumBuf.get(), checksumSize);
7483                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
7484                         ALOGE("glTestFenceNV: GL communication error, please report this issue to b.android.com.\n");
7485                         abort();
7486                 }
7487         }
7488         return retval;
7489 }
7490
7491 void glGetFenceivNV_enc(void *self , GLuint fence, GLenum pname, GLint* params)
7492 {
7493
7494         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7495         IOStream *stream = ctx->m_stream;
7496         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7497         bool useChecksum = checksumCalculator->getVersion() > 0;
7498
7499         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
7500          unsigned char *ptr;
7501          unsigned char *buf;
7502          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_params + 1*4;
7503          const size_t checksumSize = checksumCalculator->checksumByteSize();
7504          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7505         buf = stream->alloc(totalSize);
7506         ptr = buf;
7507         int tmp = OP_glGetFenceivNV;memcpy(ptr, &tmp, 4); ptr += 4;
7508         memcpy(ptr, &totalSize, 4);  ptr += 4;
7509
7510                 memcpy(ptr, &fence, 4); ptr += 4;
7511                 memcpy(ptr, &pname, 4); ptr += 4;
7512         *(unsigned int *)(ptr) = __size_params; ptr += 4;
7513
7514         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7515         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7516
7517         stream->readback(params, __size_params);
7518         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
7519         if (useChecksum) {
7520                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
7521                 stream->readback(checksumBuf.get(), checksumSize);
7522                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
7523                         ALOGE("glGetFenceivNV: GL communication error, please report this issue to b.android.com.\n");
7524                         abort();
7525                 }
7526         }
7527 }
7528
7529 void glFinishFenceNV_enc(void *self , GLuint fence)
7530 {
7531
7532         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7533         IOStream *stream = ctx->m_stream;
7534         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7535         bool useChecksum = checksumCalculator->getVersion() > 0;
7536
7537          unsigned char *ptr;
7538          unsigned char *buf;
7539          const size_t sizeWithoutChecksum = 8 + 4;
7540          const size_t checksumSize = checksumCalculator->checksumByteSize();
7541          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7542         buf = stream->alloc(totalSize);
7543         ptr = buf;
7544         int tmp = OP_glFinishFenceNV;memcpy(ptr, &tmp, 4); ptr += 4;
7545         memcpy(ptr, &totalSize, 4);  ptr += 4;
7546
7547                 memcpy(ptr, &fence, 4); ptr += 4;
7548
7549         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7550         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7551
7552 }
7553
7554 void glSetFenceNV_enc(void *self , GLuint fence, GLenum condition)
7555 {
7556
7557         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7558         IOStream *stream = ctx->m_stream;
7559         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7560         bool useChecksum = checksumCalculator->getVersion() > 0;
7561
7562          unsigned char *ptr;
7563          unsigned char *buf;
7564          const size_t sizeWithoutChecksum = 8 + 4 + 4;
7565          const size_t checksumSize = checksumCalculator->checksumByteSize();
7566          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7567         buf = stream->alloc(totalSize);
7568         ptr = buf;
7569         int tmp = OP_glSetFenceNV;memcpy(ptr, &tmp, 4); ptr += 4;
7570         memcpy(ptr, &totalSize, 4);  ptr += 4;
7571
7572                 memcpy(ptr, &fence, 4); ptr += 4;
7573                 memcpy(ptr, &condition, 4); ptr += 4;
7574
7575         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7576         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7577
7578 }
7579
7580 void glGetDriverControlsQCOM_enc(void *self , GLint* num, GLsizei size, GLuint* driverControls)
7581 {
7582
7583         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7584         IOStream *stream = ctx->m_stream;
7585         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7586         bool useChecksum = checksumCalculator->getVersion() > 0;
7587
7588         const unsigned int __size_num =  (1 * sizeof(GLint));
7589         const unsigned int __size_driverControls =  (size * sizeof(GLuint));
7590          unsigned char *ptr;
7591          unsigned char *buf;
7592          const size_t sizeWithoutChecksum = 8 + __size_num + 4 + __size_driverControls + 2*4;
7593          const size_t checksumSize = checksumCalculator->checksumByteSize();
7594          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7595         buf = stream->alloc(totalSize);
7596         ptr = buf;
7597         int tmp = OP_glGetDriverControlsQCOM;memcpy(ptr, &tmp, 4); ptr += 4;
7598         memcpy(ptr, &totalSize, 4);  ptr += 4;
7599
7600         *(unsigned int *)(ptr) = __size_num; ptr += 4;
7601                 memcpy(ptr, &size, 4); ptr += 4;
7602         *(unsigned int *)(ptr) = __size_driverControls; ptr += 4;
7603
7604         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7605         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7606
7607         stream->readback(num, __size_num);
7608         if (useChecksum) checksumCalculator->addBuffer(num, __size_num);
7609         stream->readback(driverControls, __size_driverControls);
7610         if (useChecksum) checksumCalculator->addBuffer(driverControls, __size_driverControls);
7611         if (useChecksum) {
7612                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
7613                 stream->readback(checksumBuf.get(), checksumSize);
7614                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
7615                         ALOGE("glGetDriverControlsQCOM: GL communication error, please report this issue to b.android.com.\n");
7616                         abort();
7617                 }
7618         }
7619 }
7620
7621 void glGetDriverControlStringQCOM_enc(void *self , GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar* driverControlString)
7622 {
7623
7624         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7625         IOStream *stream = ctx->m_stream;
7626         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7627         bool useChecksum = checksumCalculator->getVersion() > 0;
7628
7629         const unsigned int __size_length =  (1 * sizeof(GLsizei));
7630         const unsigned int __size_driverControlString =  (1 * sizeof(GLchar));
7631          unsigned char *ptr;
7632          unsigned char *buf;
7633          const size_t sizeWithoutChecksum = 8 + 4 + 4 + __size_length + __size_driverControlString + 2*4;
7634          const size_t checksumSize = checksumCalculator->checksumByteSize();
7635          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7636         buf = stream->alloc(totalSize);
7637         ptr = buf;
7638         int tmp = OP_glGetDriverControlStringQCOM;memcpy(ptr, &tmp, 4); ptr += 4;
7639         memcpy(ptr, &totalSize, 4);  ptr += 4;
7640
7641                 memcpy(ptr, &driverControl, 4); ptr += 4;
7642                 memcpy(ptr, &bufSize, 4); ptr += 4;
7643         *(unsigned int *)(ptr) = __size_length; ptr += 4;
7644         *(unsigned int *)(ptr) = __size_driverControlString; ptr += 4;
7645
7646         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7647         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7648
7649         stream->readback(length, __size_length);
7650         if (useChecksum) checksumCalculator->addBuffer(length, __size_length);
7651         stream->readback(driverControlString, __size_driverControlString);
7652         if (useChecksum) checksumCalculator->addBuffer(driverControlString, __size_driverControlString);
7653         if (useChecksum) {
7654                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
7655                 stream->readback(checksumBuf.get(), checksumSize);
7656                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
7657                         ALOGE("glGetDriverControlStringQCOM: GL communication error, please report this issue to b.android.com.\n");
7658                         abort();
7659                 }
7660         }
7661 }
7662
7663 void glEnableDriverControlQCOM_enc(void *self , GLuint driverControl)
7664 {
7665
7666         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7667         IOStream *stream = ctx->m_stream;
7668         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7669         bool useChecksum = checksumCalculator->getVersion() > 0;
7670
7671          unsigned char *ptr;
7672          unsigned char *buf;
7673          const size_t sizeWithoutChecksum = 8 + 4;
7674          const size_t checksumSize = checksumCalculator->checksumByteSize();
7675          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7676         buf = stream->alloc(totalSize);
7677         ptr = buf;
7678         int tmp = OP_glEnableDriverControlQCOM;memcpy(ptr, &tmp, 4); ptr += 4;
7679         memcpy(ptr, &totalSize, 4);  ptr += 4;
7680
7681                 memcpy(ptr, &driverControl, 4); ptr += 4;
7682
7683         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7684         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7685
7686 }
7687
7688 void glDisableDriverControlQCOM_enc(void *self , GLuint driverControl)
7689 {
7690
7691         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7692         IOStream *stream = ctx->m_stream;
7693         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7694         bool useChecksum = checksumCalculator->getVersion() > 0;
7695
7696          unsigned char *ptr;
7697          unsigned char *buf;
7698          const size_t sizeWithoutChecksum = 8 + 4;
7699          const size_t checksumSize = checksumCalculator->checksumByteSize();
7700          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7701         buf = stream->alloc(totalSize);
7702         ptr = buf;
7703         int tmp = OP_glDisableDriverControlQCOM;memcpy(ptr, &tmp, 4); ptr += 4;
7704         memcpy(ptr, &totalSize, 4);  ptr += 4;
7705
7706                 memcpy(ptr, &driverControl, 4); ptr += 4;
7707
7708         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7709         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7710
7711 }
7712
7713 void glExtGetTexturesQCOM_enc(void *self , GLuint* textures, GLint maxTextures, GLint* numTextures)
7714 {
7715
7716         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7717         IOStream *stream = ctx->m_stream;
7718         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7719         bool useChecksum = checksumCalculator->getVersion() > 0;
7720
7721         const unsigned int __size_textures =  (maxTextures * sizeof(GLuint));
7722         const unsigned int __size_numTextures =  (1 * sizeof(GLint));
7723          unsigned char *ptr;
7724          unsigned char *buf;
7725          const size_t sizeWithoutChecksum = 8 + __size_textures + 4 + __size_numTextures + 2*4;
7726          const size_t checksumSize = checksumCalculator->checksumByteSize();
7727          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7728         buf = stream->alloc(totalSize);
7729         ptr = buf;
7730         int tmp = OP_glExtGetTexturesQCOM;memcpy(ptr, &tmp, 4); ptr += 4;
7731         memcpy(ptr, &totalSize, 4);  ptr += 4;
7732
7733         *(unsigned int *)(ptr) = __size_textures; ptr += 4;
7734                 memcpy(ptr, &maxTextures, 4); ptr += 4;
7735         *(unsigned int *)(ptr) = __size_numTextures; ptr += 4;
7736
7737         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7738         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7739
7740         stream->readback(textures, __size_textures);
7741         if (useChecksum) checksumCalculator->addBuffer(textures, __size_textures);
7742         stream->readback(numTextures, __size_numTextures);
7743         if (useChecksum) checksumCalculator->addBuffer(numTextures, __size_numTextures);
7744         if (useChecksum) {
7745                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
7746                 stream->readback(checksumBuf.get(), checksumSize);
7747                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
7748                         ALOGE("glExtGetTexturesQCOM: GL communication error, please report this issue to b.android.com.\n");
7749                         abort();
7750                 }
7751         }
7752 }
7753
7754 void glExtGetBuffersQCOM_enc(void *self , GLuint* buffers, GLint maxBuffers, GLint* numBuffers)
7755 {
7756
7757         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7758         IOStream *stream = ctx->m_stream;
7759         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7760         bool useChecksum = checksumCalculator->getVersion() > 0;
7761
7762         const unsigned int __size_buffers =  (maxBuffers * sizeof(GLuint));
7763         const unsigned int __size_numBuffers =  (1 * sizeof(GLint));
7764          unsigned char *ptr;
7765          unsigned char *buf;
7766          const size_t sizeWithoutChecksum = 8 + __size_buffers + 4 + __size_numBuffers + 2*4;
7767          const size_t checksumSize = checksumCalculator->checksumByteSize();
7768          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7769         buf = stream->alloc(totalSize);
7770         ptr = buf;
7771         int tmp = OP_glExtGetBuffersQCOM;memcpy(ptr, &tmp, 4); ptr += 4;
7772         memcpy(ptr, &totalSize, 4);  ptr += 4;
7773
7774         *(unsigned int *)(ptr) = __size_buffers; ptr += 4;
7775                 memcpy(ptr, &maxBuffers, 4); ptr += 4;
7776         *(unsigned int *)(ptr) = __size_numBuffers; ptr += 4;
7777
7778         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7779         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7780
7781         stream->readback(buffers, __size_buffers);
7782         if (useChecksum) checksumCalculator->addBuffer(buffers, __size_buffers);
7783         stream->readback(numBuffers, __size_numBuffers);
7784         if (useChecksum) checksumCalculator->addBuffer(numBuffers, __size_numBuffers);
7785         if (useChecksum) {
7786                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
7787                 stream->readback(checksumBuf.get(), checksumSize);
7788                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
7789                         ALOGE("glExtGetBuffersQCOM: GL communication error, please report this issue to b.android.com.\n");
7790                         abort();
7791                 }
7792         }
7793 }
7794
7795 void glExtGetRenderbuffersQCOM_enc(void *self , GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers)
7796 {
7797
7798         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7799         IOStream *stream = ctx->m_stream;
7800         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7801         bool useChecksum = checksumCalculator->getVersion() > 0;
7802
7803         const unsigned int __size_renderbuffers =  (maxRenderbuffers * sizeof(GLuint));
7804         const unsigned int __size_numRenderbuffers =  (1 * sizeof(GLint));
7805          unsigned char *ptr;
7806          unsigned char *buf;
7807          const size_t sizeWithoutChecksum = 8 + __size_renderbuffers + 4 + __size_numRenderbuffers + 2*4;
7808          const size_t checksumSize = checksumCalculator->checksumByteSize();
7809          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7810         buf = stream->alloc(totalSize);
7811         ptr = buf;
7812         int tmp = OP_glExtGetRenderbuffersQCOM;memcpy(ptr, &tmp, 4); ptr += 4;
7813         memcpy(ptr, &totalSize, 4);  ptr += 4;
7814
7815         *(unsigned int *)(ptr) = __size_renderbuffers; ptr += 4;
7816                 memcpy(ptr, &maxRenderbuffers, 4); ptr += 4;
7817         *(unsigned int *)(ptr) = __size_numRenderbuffers; ptr += 4;
7818
7819         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7820         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7821
7822         stream->readback(renderbuffers, __size_renderbuffers);
7823         if (useChecksum) checksumCalculator->addBuffer(renderbuffers, __size_renderbuffers);
7824         stream->readback(numRenderbuffers, __size_numRenderbuffers);
7825         if (useChecksum) checksumCalculator->addBuffer(numRenderbuffers, __size_numRenderbuffers);
7826         if (useChecksum) {
7827                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
7828                 stream->readback(checksumBuf.get(), checksumSize);
7829                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
7830                         ALOGE("glExtGetRenderbuffersQCOM: GL communication error, please report this issue to b.android.com.\n");
7831                         abort();
7832                 }
7833         }
7834 }
7835
7836 void glExtGetFramebuffersQCOM_enc(void *self , GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers)
7837 {
7838
7839         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7840         IOStream *stream = ctx->m_stream;
7841         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7842         bool useChecksum = checksumCalculator->getVersion() > 0;
7843
7844         const unsigned int __size_framebuffers =  (maxFramebuffers * sizeof(GLuint));
7845         const unsigned int __size_numFramebuffers =  (1 * sizeof(GLint));
7846          unsigned char *ptr;
7847          unsigned char *buf;
7848          const size_t sizeWithoutChecksum = 8 + __size_framebuffers + 4 + __size_numFramebuffers + 2*4;
7849          const size_t checksumSize = checksumCalculator->checksumByteSize();
7850          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7851         buf = stream->alloc(totalSize);
7852         ptr = buf;
7853         int tmp = OP_glExtGetFramebuffersQCOM;memcpy(ptr, &tmp, 4); ptr += 4;
7854         memcpy(ptr, &totalSize, 4);  ptr += 4;
7855
7856         *(unsigned int *)(ptr) = __size_framebuffers; ptr += 4;
7857                 memcpy(ptr, &maxFramebuffers, 4); ptr += 4;
7858         *(unsigned int *)(ptr) = __size_numFramebuffers; ptr += 4;
7859
7860         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7861         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7862
7863         stream->readback(framebuffers, __size_framebuffers);
7864         if (useChecksum) checksumCalculator->addBuffer(framebuffers, __size_framebuffers);
7865         stream->readback(numFramebuffers, __size_numFramebuffers);
7866         if (useChecksum) checksumCalculator->addBuffer(numFramebuffers, __size_numFramebuffers);
7867         if (useChecksum) {
7868                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
7869                 stream->readback(checksumBuf.get(), checksumSize);
7870                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
7871                         ALOGE("glExtGetFramebuffersQCOM: GL communication error, please report this issue to b.android.com.\n");
7872                         abort();
7873                 }
7874         }
7875 }
7876
7877 void glExtGetTexLevelParameterivQCOM_enc(void *self , GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params)
7878 {
7879
7880         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7881         IOStream *stream = ctx->m_stream;
7882         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7883         bool useChecksum = checksumCalculator->getVersion() > 0;
7884
7885         const unsigned int __size_params =  (glUtilsParamSize(pname) * sizeof(GLint));
7886          unsigned char *ptr;
7887          unsigned char *buf;
7888          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + __size_params + 1*4;
7889          const size_t checksumSize = checksumCalculator->checksumByteSize();
7890          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7891         buf = stream->alloc(totalSize);
7892         ptr = buf;
7893         int tmp = OP_glExtGetTexLevelParameterivQCOM;memcpy(ptr, &tmp, 4); ptr += 4;
7894         memcpy(ptr, &totalSize, 4);  ptr += 4;
7895
7896                 memcpy(ptr, &texture, 4); ptr += 4;
7897                 memcpy(ptr, &face, 4); ptr += 4;
7898                 memcpy(ptr, &level, 4); ptr += 4;
7899                 memcpy(ptr, &pname, 4); ptr += 4;
7900         *(unsigned int *)(ptr) = __size_params; ptr += 4;
7901
7902         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7903         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7904
7905         stream->readback(params, __size_params);
7906         if (useChecksum) checksumCalculator->addBuffer(params, __size_params);
7907         if (useChecksum) {
7908                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
7909                 stream->readback(checksumBuf.get(), checksumSize);
7910                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
7911                         ALOGE("glExtGetTexLevelParameterivQCOM: GL communication error, please report this issue to b.android.com.\n");
7912                         abort();
7913                 }
7914         }
7915 }
7916
7917 void glExtTexObjectStateOverrideiQCOM_enc(void *self , GLenum target, GLenum pname, GLint param)
7918 {
7919
7920         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7921         IOStream *stream = ctx->m_stream;
7922         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7923         bool useChecksum = checksumCalculator->getVersion() > 0;
7924
7925          unsigned char *ptr;
7926          unsigned char *buf;
7927          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
7928          const size_t checksumSize = checksumCalculator->checksumByteSize();
7929          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7930         buf = stream->alloc(totalSize);
7931         ptr = buf;
7932         int tmp = OP_glExtTexObjectStateOverrideiQCOM;memcpy(ptr, &tmp, 4); ptr += 4;
7933         memcpy(ptr, &totalSize, 4);  ptr += 4;
7934
7935                 memcpy(ptr, &target, 4); ptr += 4;
7936                 memcpy(ptr, &pname, 4); ptr += 4;
7937                 memcpy(ptr, &param, 4); ptr += 4;
7938
7939         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7940         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7941
7942 }
7943
7944 void glExtGetTexSubImageQCOM_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* texels)
7945 {
7946
7947         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7948         IOStream *stream = ctx->m_stream;
7949         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7950         bool useChecksum = checksumCalculator->getVersion() > 0;
7951
7952         const unsigned int __size_texels =  (depth * glesv1_enc::pixelDataSize(self, width, height, format, type, 0));
7953          unsigned char *ptr;
7954          unsigned char *buf;
7955          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_texels + 1*4;
7956          const size_t checksumSize = checksumCalculator->checksumByteSize();
7957          const size_t totalSize = sizeWithoutChecksum + checksumSize;
7958         buf = stream->alloc(totalSize);
7959         ptr = buf;
7960         int tmp = OP_glExtGetTexSubImageQCOM;memcpy(ptr, &tmp, 4); ptr += 4;
7961         memcpy(ptr, &totalSize, 4);  ptr += 4;
7962
7963                 memcpy(ptr, &target, 4); ptr += 4;
7964                 memcpy(ptr, &level, 4); ptr += 4;
7965                 memcpy(ptr, &xoffset, 4); ptr += 4;
7966                 memcpy(ptr, &yoffset, 4); ptr += 4;
7967                 memcpy(ptr, &zoffset, 4); ptr += 4;
7968                 memcpy(ptr, &width, 4); ptr += 4;
7969                 memcpy(ptr, &height, 4); ptr += 4;
7970                 memcpy(ptr, &depth, 4); ptr += 4;
7971                 memcpy(ptr, &format, 4); ptr += 4;
7972                 memcpy(ptr, &type, 4); ptr += 4;
7973         *(unsigned int *)(ptr) = __size_texels; ptr += 4;
7974
7975         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
7976         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
7977
7978         stream->readback(texels, __size_texels);
7979         if (useChecksum) checksumCalculator->addBuffer(texels, __size_texels);
7980         if (useChecksum) {
7981                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
7982                 stream->readback(checksumBuf.get(), checksumSize);
7983                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
7984                         ALOGE("glExtGetTexSubImageQCOM: GL communication error, please report this issue to b.android.com.\n");
7985                         abort();
7986                 }
7987         }
7988 }
7989
7990 void glExtGetShadersQCOM_enc(void *self , GLuint* shaders, GLint maxShaders, GLint* numShaders)
7991 {
7992
7993         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
7994         IOStream *stream = ctx->m_stream;
7995         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
7996         bool useChecksum = checksumCalculator->getVersion() > 0;
7997
7998         const unsigned int __size_shaders =  (maxShaders * sizeof(GLuint));
7999         const unsigned int __size_numShaders =  (1 * sizeof(GLint));
8000          unsigned char *ptr;
8001          unsigned char *buf;
8002          const size_t sizeWithoutChecksum = 8 + __size_shaders + 4 + __size_numShaders + 2*4;
8003          const size_t checksumSize = checksumCalculator->checksumByteSize();
8004          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8005         buf = stream->alloc(totalSize);
8006         ptr = buf;
8007         int tmp = OP_glExtGetShadersQCOM;memcpy(ptr, &tmp, 4); ptr += 4;
8008         memcpy(ptr, &totalSize, 4);  ptr += 4;
8009
8010         *(unsigned int *)(ptr) = __size_shaders; ptr += 4;
8011                 memcpy(ptr, &maxShaders, 4); ptr += 4;
8012         *(unsigned int *)(ptr) = __size_numShaders; ptr += 4;
8013
8014         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8015         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8016
8017         stream->readback(shaders, __size_shaders);
8018         if (useChecksum) checksumCalculator->addBuffer(shaders, __size_shaders);
8019         stream->readback(numShaders, __size_numShaders);
8020         if (useChecksum) checksumCalculator->addBuffer(numShaders, __size_numShaders);
8021         if (useChecksum) {
8022                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
8023                 stream->readback(checksumBuf.get(), checksumSize);
8024                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
8025                         ALOGE("glExtGetShadersQCOM: GL communication error, please report this issue to b.android.com.\n");
8026                         abort();
8027                 }
8028         }
8029 }
8030
8031 void glExtGetProgramsQCOM_enc(void *self , GLuint* programs, GLint maxPrograms, GLint* numPrograms)
8032 {
8033
8034         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
8035         IOStream *stream = ctx->m_stream;
8036         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8037         bool useChecksum = checksumCalculator->getVersion() > 0;
8038
8039         const unsigned int __size_programs =  (maxPrograms * sizeof(GLuint));
8040         const unsigned int __size_numPrograms =  (1 * sizeof(GLint));
8041          unsigned char *ptr;
8042          unsigned char *buf;
8043          const size_t sizeWithoutChecksum = 8 + __size_programs + 4 + __size_numPrograms + 2*4;
8044          const size_t checksumSize = checksumCalculator->checksumByteSize();
8045          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8046         buf = stream->alloc(totalSize);
8047         ptr = buf;
8048         int tmp = OP_glExtGetProgramsQCOM;memcpy(ptr, &tmp, 4); ptr += 4;
8049         memcpy(ptr, &totalSize, 4);  ptr += 4;
8050
8051         *(unsigned int *)(ptr) = __size_programs; ptr += 4;
8052                 memcpy(ptr, &maxPrograms, 4); ptr += 4;
8053         *(unsigned int *)(ptr) = __size_numPrograms; ptr += 4;
8054
8055         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8056         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8057
8058         stream->readback(programs, __size_programs);
8059         if (useChecksum) checksumCalculator->addBuffer(programs, __size_programs);
8060         stream->readback(numPrograms, __size_numPrograms);
8061         if (useChecksum) checksumCalculator->addBuffer(numPrograms, __size_numPrograms);
8062         if (useChecksum) {
8063                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
8064                 stream->readback(checksumBuf.get(), checksumSize);
8065                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
8066                         ALOGE("glExtGetProgramsQCOM: GL communication error, please report this issue to b.android.com.\n");
8067                         abort();
8068                 }
8069         }
8070 }
8071
8072 GLboolean glExtIsProgramBinaryQCOM_enc(void *self , GLuint program)
8073 {
8074
8075         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
8076         IOStream *stream = ctx->m_stream;
8077         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8078         bool useChecksum = checksumCalculator->getVersion() > 0;
8079
8080          unsigned char *ptr;
8081          unsigned char *buf;
8082          const size_t sizeWithoutChecksum = 8 + 4;
8083          const size_t checksumSize = checksumCalculator->checksumByteSize();
8084          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8085         buf = stream->alloc(totalSize);
8086         ptr = buf;
8087         int tmp = OP_glExtIsProgramBinaryQCOM;memcpy(ptr, &tmp, 4); ptr += 4;
8088         memcpy(ptr, &totalSize, 4);  ptr += 4;
8089
8090                 memcpy(ptr, &program, 4); ptr += 4;
8091
8092         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8093         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8094
8095
8096         GLboolean retval;
8097         stream->readback(&retval, 1);
8098         if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
8099         if (useChecksum) {
8100                 std::unique_ptr<unsigned char[]> checksumBuf(new unsigned char[checksumSize]);
8101                 stream->readback(checksumBuf.get(), checksumSize);
8102                 if (!checksumCalculator->validate(checksumBuf.get(), checksumSize)) {
8103                         ALOGE("glExtIsProgramBinaryQCOM: GL communication error, please report this issue to b.android.com.\n");
8104                         abort();
8105                 }
8106         }
8107         return retval;
8108 }
8109
8110 void glStartTilingQCOM_enc(void *self , GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask)
8111 {
8112
8113         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
8114         IOStream *stream = ctx->m_stream;
8115         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8116         bool useChecksum = checksumCalculator->getVersion() > 0;
8117
8118          unsigned char *ptr;
8119          unsigned char *buf;
8120          const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
8121          const size_t checksumSize = checksumCalculator->checksumByteSize();
8122          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8123         buf = stream->alloc(totalSize);
8124         ptr = buf;
8125         int tmp = OP_glStartTilingQCOM;memcpy(ptr, &tmp, 4); ptr += 4;
8126         memcpy(ptr, &totalSize, 4);  ptr += 4;
8127
8128                 memcpy(ptr, &x, 4); ptr += 4;
8129                 memcpy(ptr, &y, 4); ptr += 4;
8130                 memcpy(ptr, &width, 4); ptr += 4;
8131                 memcpy(ptr, &height, 4); ptr += 4;
8132                 memcpy(ptr, &preserveMask, 4); ptr += 4;
8133
8134         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8135         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8136
8137 }
8138
8139 void glEndTilingQCOM_enc(void *self , GLbitfield preserveMask)
8140 {
8141
8142         gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
8143         IOStream *stream = ctx->m_stream;
8144         ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
8145         bool useChecksum = checksumCalculator->getVersion() > 0;
8146
8147          unsigned char *ptr;
8148          unsigned char *buf;
8149          const size_t sizeWithoutChecksum = 8 + 4;
8150          const size_t checksumSize = checksumCalculator->checksumByteSize();
8151          const size_t totalSize = sizeWithoutChecksum + checksumSize;
8152         buf = stream->alloc(totalSize);
8153         ptr = buf;
8154         int tmp = OP_glEndTilingQCOM;memcpy(ptr, &tmp, 4); ptr += 4;
8155         memcpy(ptr, &totalSize, 4);  ptr += 4;
8156
8157                 memcpy(ptr, &preserveMask, 4); ptr += 4;
8158
8159         if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
8160         if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
8161
8162 }
8163
8164 }  // namespace
8165
8166 gl_encoder_context_t::gl_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator)
8167 {
8168         m_stream = stream;
8169         m_checksumCalculator = checksumCalculator;
8170
8171         this->glAlphaFunc = &glAlphaFunc_enc;
8172         this->glClearColor = &glClearColor_enc;
8173         this->glClearDepthf = &glClearDepthf_enc;
8174         this->glClipPlanef = &glClipPlanef_enc;
8175         this->glColor4f = &glColor4f_enc;
8176         this->glDepthRangef = &glDepthRangef_enc;
8177         this->glFogf = &glFogf_enc;
8178         this->glFogfv = &glFogfv_enc;
8179         this->glFrustumf = &glFrustumf_enc;
8180         this->glGetClipPlanef = &glGetClipPlanef_enc;
8181         this->glGetFloatv = &glGetFloatv_enc;
8182         this->glGetLightfv = &glGetLightfv_enc;
8183         this->glGetMaterialfv = &glGetMaterialfv_enc;
8184         this->glGetTexEnvfv = &glGetTexEnvfv_enc;
8185         this->glGetTexParameterfv = &glGetTexParameterfv_enc;
8186         this->glLightModelf = &glLightModelf_enc;
8187         this->glLightModelfv = &glLightModelfv_enc;
8188         this->glLightf = &glLightf_enc;
8189         this->glLightfv = &glLightfv_enc;
8190         this->glLineWidth = &glLineWidth_enc;
8191         this->glLoadMatrixf = &glLoadMatrixf_enc;
8192         this->glMaterialf = &glMaterialf_enc;
8193         this->glMaterialfv = &glMaterialfv_enc;
8194         this->glMultMatrixf = &glMultMatrixf_enc;
8195         this->glMultiTexCoord4f = &glMultiTexCoord4f_enc;
8196         this->glNormal3f = &glNormal3f_enc;
8197         this->glOrthof = &glOrthof_enc;
8198         this->glPointParameterf = &glPointParameterf_enc;
8199         this->glPointParameterfv = &glPointParameterfv_enc;
8200         this->glPointSize = &glPointSize_enc;
8201         this->glPolygonOffset = &glPolygonOffset_enc;
8202         this->glRotatef = &glRotatef_enc;
8203         this->glScalef = &glScalef_enc;
8204         this->glTexEnvf = &glTexEnvf_enc;
8205         this->glTexEnvfv = &glTexEnvfv_enc;
8206         this->glTexParameterf = &glTexParameterf_enc;
8207         this->glTexParameterfv = &glTexParameterfv_enc;
8208         this->glTranslatef = &glTranslatef_enc;
8209         this->glActiveTexture = &glActiveTexture_enc;
8210         this->glAlphaFuncx = &glAlphaFuncx_enc;
8211         this->glBindBuffer = &glBindBuffer_enc;
8212         this->glBindTexture = &glBindTexture_enc;
8213         this->glBlendFunc = &glBlendFunc_enc;
8214         this->glBufferData = &glBufferData_enc;
8215         this->glBufferSubData = &glBufferSubData_enc;
8216         this->glClear = &glClear_enc;
8217         this->glClearColorx = &glClearColorx_enc;
8218         this->glClearDepthx = &glClearDepthx_enc;
8219         this->glClearStencil = &glClearStencil_enc;
8220         this->glClientActiveTexture = &glClientActiveTexture_enc;
8221         this->glColor4ub = &glColor4ub_enc;
8222         this->glColor4x = &glColor4x_enc;
8223         this->glColorMask = &glColorMask_enc;
8224         this->glColorPointer = (glColorPointer_client_proc_t) &enc_unsupported;
8225         this->glCompressedTexImage2D = &glCompressedTexImage2D_enc;
8226         this->glCompressedTexSubImage2D = &glCompressedTexSubImage2D_enc;
8227         this->glCopyTexImage2D = &glCopyTexImage2D_enc;
8228         this->glCopyTexSubImage2D = &glCopyTexSubImage2D_enc;
8229         this->glCullFace = &glCullFace_enc;
8230         this->glDeleteBuffers = &glDeleteBuffers_enc;
8231         this->glDeleteTextures = &glDeleteTextures_enc;
8232         this->glDepthFunc = &glDepthFunc_enc;
8233         this->glDepthMask = &glDepthMask_enc;
8234         this->glDepthRangex = &glDepthRangex_enc;
8235         this->glDisable = &glDisable_enc;
8236         this->glDisableClientState = &glDisableClientState_enc;
8237         this->glDrawArrays = &glDrawArrays_enc;
8238         this->glDrawElements = (glDrawElements_client_proc_t) &enc_unsupported;
8239         this->glEnable = &glEnable_enc;
8240         this->glEnableClientState = &glEnableClientState_enc;
8241         this->glFinish = &glFinish_enc;
8242         this->glFlush = &glFlush_enc;
8243         this->glFogx = &glFogx_enc;
8244         this->glFogxv = &glFogxv_enc;
8245         this->glFrontFace = &glFrontFace_enc;
8246         this->glFrustumx = &glFrustumx_enc;
8247         this->glGetBooleanv = &glGetBooleanv_enc;
8248         this->glGetBufferParameteriv = &glGetBufferParameteriv_enc;
8249         this->glClipPlanex = &glClipPlanex_enc;
8250         this->glGenBuffers = &glGenBuffers_enc;
8251         this->glGenTextures = &glGenTextures_enc;
8252         this->glGetError = &glGetError_enc;
8253         this->glGetFixedv = &glGetFixedv_enc;
8254         this->glGetIntegerv = &glGetIntegerv_enc;
8255         this->glGetLightxv = &glGetLightxv_enc;
8256         this->glGetMaterialxv = &glGetMaterialxv_enc;
8257         this->glGetPointerv = (glGetPointerv_client_proc_t) &enc_unsupported;
8258         this->glGetString = (glGetString_client_proc_t) &enc_unsupported;
8259         this->glGetTexEnviv = &glGetTexEnviv_enc;
8260         this->glGetTexEnvxv = &glGetTexEnvxv_enc;
8261         this->glGetTexParameteriv = &glGetTexParameteriv_enc;
8262         this->glGetTexParameterxv = &glGetTexParameterxv_enc;
8263         this->glHint = &glHint_enc;
8264         this->glIsBuffer = &glIsBuffer_enc;
8265         this->glIsEnabled = &glIsEnabled_enc;
8266         this->glIsTexture = &glIsTexture_enc;
8267         this->glLightModelx = &glLightModelx_enc;
8268         this->glLightModelxv = &glLightModelxv_enc;
8269         this->glLightx = &glLightx_enc;
8270         this->glLightxv = &glLightxv_enc;
8271         this->glLineWidthx = &glLineWidthx_enc;
8272         this->glLoadIdentity = &glLoadIdentity_enc;
8273         this->glLoadMatrixx = &glLoadMatrixx_enc;
8274         this->glLogicOp = &glLogicOp_enc;
8275         this->glMaterialx = &glMaterialx_enc;
8276         this->glMaterialxv = &glMaterialxv_enc;
8277         this->glMatrixMode = &glMatrixMode_enc;
8278         this->glMultMatrixx = &glMultMatrixx_enc;
8279         this->glMultiTexCoord4x = &glMultiTexCoord4x_enc;
8280         this->glNormal3x = &glNormal3x_enc;
8281         this->glNormalPointer = (glNormalPointer_client_proc_t) &enc_unsupported;
8282         this->glOrthox = &glOrthox_enc;
8283         this->glPixelStorei = &glPixelStorei_enc;
8284         this->glPointParameterx = &glPointParameterx_enc;
8285         this->glPointParameterxv = &glPointParameterxv_enc;
8286         this->glPointSizex = &glPointSizex_enc;
8287         this->glPolygonOffsetx = &glPolygonOffsetx_enc;
8288         this->glPopMatrix = &glPopMatrix_enc;
8289         this->glPushMatrix = &glPushMatrix_enc;
8290         this->glReadPixels = &glReadPixels_enc;
8291         this->glRotatex = &glRotatex_enc;
8292         this->glSampleCoverage = &glSampleCoverage_enc;
8293         this->glSampleCoveragex = &glSampleCoveragex_enc;
8294         this->glScalex = &glScalex_enc;
8295         this->glScissor = &glScissor_enc;
8296         this->glShadeModel = &glShadeModel_enc;
8297         this->glStencilFunc = &glStencilFunc_enc;
8298         this->glStencilMask = &glStencilMask_enc;
8299         this->glStencilOp = &glStencilOp_enc;
8300         this->glTexCoordPointer = (glTexCoordPointer_client_proc_t) &enc_unsupported;
8301         this->glTexEnvi = &glTexEnvi_enc;
8302         this->glTexEnvx = &glTexEnvx_enc;
8303         this->glTexEnviv = &glTexEnviv_enc;
8304         this->glTexEnvxv = &glTexEnvxv_enc;
8305         this->glTexImage2D = &glTexImage2D_enc;
8306         this->glTexParameteri = &glTexParameteri_enc;
8307         this->glTexParameterx = &glTexParameterx_enc;
8308         this->glTexParameteriv = &glTexParameteriv_enc;
8309         this->glTexParameterxv = &glTexParameterxv_enc;
8310         this->glTexSubImage2D = &glTexSubImage2D_enc;
8311         this->glTranslatex = &glTranslatex_enc;
8312         this->glVertexPointer = (glVertexPointer_client_proc_t) &enc_unsupported;
8313         this->glViewport = &glViewport_enc;
8314         this->glPointSizePointerOES = (glPointSizePointerOES_client_proc_t) &enc_unsupported;
8315         this->glVertexPointerOffset = &glVertexPointerOffset_enc;
8316         this->glColorPointerOffset = &glColorPointerOffset_enc;
8317         this->glNormalPointerOffset = &glNormalPointerOffset_enc;
8318         this->glPointSizePointerOffset = &glPointSizePointerOffset_enc;
8319         this->glTexCoordPointerOffset = &glTexCoordPointerOffset_enc;
8320         this->glWeightPointerOffset = &glWeightPointerOffset_enc;
8321         this->glMatrixIndexPointerOffset = &glMatrixIndexPointerOffset_enc;
8322         this->glVertexPointerData = &glVertexPointerData_enc;
8323         this->glColorPointerData = &glColorPointerData_enc;
8324         this->glNormalPointerData = &glNormalPointerData_enc;
8325         this->glTexCoordPointerData = &glTexCoordPointerData_enc;
8326         this->glPointSizePointerData = &glPointSizePointerData_enc;
8327         this->glWeightPointerData = &glWeightPointerData_enc;
8328         this->glMatrixIndexPointerData = &glMatrixIndexPointerData_enc;
8329         this->glDrawElementsOffset = &glDrawElementsOffset_enc;
8330         this->glDrawElementsData = &glDrawElementsData_enc;
8331         this->glGetCompressedTextureFormats = &glGetCompressedTextureFormats_enc;
8332         this->glFinishRoundTrip = &glFinishRoundTrip_enc;
8333         this->glBlendEquationSeparateOES = &glBlendEquationSeparateOES_enc;
8334         this->glBlendFuncSeparateOES = &glBlendFuncSeparateOES_enc;
8335         this->glBlendEquationOES = &glBlendEquationOES_enc;
8336         this->glDrawTexsOES = &glDrawTexsOES_enc;
8337         this->glDrawTexiOES = &glDrawTexiOES_enc;
8338         this->glDrawTexxOES = &glDrawTexxOES_enc;
8339         this->glDrawTexsvOES = &glDrawTexsvOES_enc;
8340         this->glDrawTexivOES = &glDrawTexivOES_enc;
8341         this->glDrawTexxvOES = &glDrawTexxvOES_enc;
8342         this->glDrawTexfOES = &glDrawTexfOES_enc;
8343         this->glDrawTexfvOES = &glDrawTexfvOES_enc;
8344         this->glEGLImageTargetTexture2DOES = &glEGLImageTargetTexture2DOES_enc;
8345         this->glEGLImageTargetRenderbufferStorageOES = &glEGLImageTargetRenderbufferStorageOES_enc;
8346         this->glAlphaFuncxOES = &glAlphaFuncxOES_enc;
8347         this->glClearColorxOES = &glClearColorxOES_enc;
8348         this->glClearDepthxOES = &glClearDepthxOES_enc;
8349         this->glClipPlanexOES = &glClipPlanexOES_enc;
8350         this->glClipPlanexIMG = &glClipPlanexIMG_enc;
8351         this->glColor4xOES = &glColor4xOES_enc;
8352         this->glDepthRangexOES = &glDepthRangexOES_enc;
8353         this->glFogxOES = &glFogxOES_enc;
8354         this->glFogxvOES = &glFogxvOES_enc;
8355         this->glFrustumxOES = &glFrustumxOES_enc;
8356         this->glGetClipPlanexOES = &glGetClipPlanexOES_enc;
8357         this->glGetClipPlanex = &glGetClipPlanex_enc;
8358         this->glGetFixedvOES = &glGetFixedvOES_enc;
8359         this->glGetLightxvOES = &glGetLightxvOES_enc;
8360         this->glGetMaterialxvOES = &glGetMaterialxvOES_enc;
8361         this->glGetTexEnvxvOES = &glGetTexEnvxvOES_enc;
8362         this->glGetTexParameterxvOES = &glGetTexParameterxvOES_enc;
8363         this->glLightModelxOES = &glLightModelxOES_enc;
8364         this->glLightModelxvOES = &glLightModelxvOES_enc;
8365         this->glLightxOES = &glLightxOES_enc;
8366         this->glLightxvOES = &glLightxvOES_enc;
8367         this->glLineWidthxOES = &glLineWidthxOES_enc;
8368         this->glLoadMatrixxOES = &glLoadMatrixxOES_enc;
8369         this->glMaterialxOES = &glMaterialxOES_enc;
8370         this->glMaterialxvOES = &glMaterialxvOES_enc;
8371         this->glMultMatrixxOES = &glMultMatrixxOES_enc;
8372         this->glMultiTexCoord4xOES = &glMultiTexCoord4xOES_enc;
8373         this->glNormal3xOES = &glNormal3xOES_enc;
8374         this->glOrthoxOES = &glOrthoxOES_enc;
8375         this->glPointParameterxOES = &glPointParameterxOES_enc;
8376         this->glPointParameterxvOES = &glPointParameterxvOES_enc;
8377         this->glPointSizexOES = &glPointSizexOES_enc;
8378         this->glPolygonOffsetxOES = &glPolygonOffsetxOES_enc;
8379         this->glRotatexOES = &glRotatexOES_enc;
8380         this->glSampleCoveragexOES = &glSampleCoveragexOES_enc;
8381         this->glScalexOES = &glScalexOES_enc;
8382         this->glTexEnvxOES = &glTexEnvxOES_enc;
8383         this->glTexEnvxvOES = &glTexEnvxvOES_enc;
8384         this->glTexParameterxOES = &glTexParameterxOES_enc;
8385         this->glTexParameterxvOES = &glTexParameterxvOES_enc;
8386         this->glTranslatexOES = &glTranslatexOES_enc;
8387         this->glIsRenderbufferOES = &glIsRenderbufferOES_enc;
8388         this->glBindRenderbufferOES = &glBindRenderbufferOES_enc;
8389         this->glDeleteRenderbuffersOES = &glDeleteRenderbuffersOES_enc;
8390         this->glGenRenderbuffersOES = &glGenRenderbuffersOES_enc;
8391         this->glRenderbufferStorageOES = &glRenderbufferStorageOES_enc;
8392         this->glGetRenderbufferParameterivOES = &glGetRenderbufferParameterivOES_enc;
8393         this->glIsFramebufferOES = &glIsFramebufferOES_enc;
8394         this->glBindFramebufferOES = &glBindFramebufferOES_enc;
8395         this->glDeleteFramebuffersOES = &glDeleteFramebuffersOES_enc;
8396         this->glGenFramebuffersOES = &glGenFramebuffersOES_enc;
8397         this->glCheckFramebufferStatusOES = &glCheckFramebufferStatusOES_enc;
8398         this->glFramebufferRenderbufferOES = &glFramebufferRenderbufferOES_enc;
8399         this->glFramebufferTexture2DOES = &glFramebufferTexture2DOES_enc;
8400         this->glGetFramebufferAttachmentParameterivOES = &glGetFramebufferAttachmentParameterivOES_enc;
8401         this->glGenerateMipmapOES = &glGenerateMipmapOES_enc;
8402         this->glMapBufferOES = (glMapBufferOES_client_proc_t) &enc_unsupported;
8403         this->glUnmapBufferOES = &glUnmapBufferOES_enc;
8404         this->glGetBufferPointervOES = (glGetBufferPointervOES_client_proc_t) &enc_unsupported;
8405         this->glCurrentPaletteMatrixOES = &glCurrentPaletteMatrixOES_enc;
8406         this->glLoadPaletteFromModelViewMatrixOES = &glLoadPaletteFromModelViewMatrixOES_enc;
8407         this->glMatrixIndexPointerOES = (glMatrixIndexPointerOES_client_proc_t) &enc_unsupported;
8408         this->glWeightPointerOES = (glWeightPointerOES_client_proc_t) &enc_unsupported;
8409         this->glQueryMatrixxOES = &glQueryMatrixxOES_enc;
8410         this->glDepthRangefOES = &glDepthRangefOES_enc;
8411         this->glFrustumfOES = &glFrustumfOES_enc;
8412         this->glOrthofOES = &glOrthofOES_enc;
8413         this->glClipPlanefOES = &glClipPlanefOES_enc;
8414         this->glClipPlanefIMG = &glClipPlanefIMG_enc;
8415         this->glGetClipPlanefOES = &glGetClipPlanefOES_enc;
8416         this->glClearDepthfOES = &glClearDepthfOES_enc;
8417         this->glTexGenfOES = &glTexGenfOES_enc;
8418         this->glTexGenfvOES = &glTexGenfvOES_enc;
8419         this->glTexGeniOES = &glTexGeniOES_enc;
8420         this->glTexGenivOES = &glTexGenivOES_enc;
8421         this->glTexGenxOES = &glTexGenxOES_enc;
8422         this->glTexGenxvOES = &glTexGenxvOES_enc;
8423         this->glGetTexGenfvOES = &glGetTexGenfvOES_enc;
8424         this->glGetTexGenivOES = &glGetTexGenivOES_enc;
8425         this->glGetTexGenxvOES = &glGetTexGenxvOES_enc;
8426         this->glBindVertexArrayOES = &glBindVertexArrayOES_enc;
8427         this->glDeleteVertexArraysOES = &glDeleteVertexArraysOES_enc;
8428         this->glGenVertexArraysOES = &glGenVertexArraysOES_enc;
8429         this->glIsVertexArrayOES = &glIsVertexArrayOES_enc;
8430         this->glDiscardFramebufferEXT = &glDiscardFramebufferEXT_enc;
8431         this->glMultiDrawArraysEXT = (glMultiDrawArraysEXT_client_proc_t) &enc_unsupported;
8432         this->glMultiDrawElementsEXT = (glMultiDrawElementsEXT_client_proc_t) &enc_unsupported;
8433         this->glMultiDrawArraysSUN = (glMultiDrawArraysSUN_client_proc_t) &enc_unsupported;
8434         this->glMultiDrawElementsSUN = (glMultiDrawElementsSUN_client_proc_t) &enc_unsupported;
8435         this->glRenderbufferStorageMultisampleIMG = &glRenderbufferStorageMultisampleIMG_enc;
8436         this->glFramebufferTexture2DMultisampleIMG = &glFramebufferTexture2DMultisampleIMG_enc;
8437         this->glDeleteFencesNV = &glDeleteFencesNV_enc;
8438         this->glGenFencesNV = &glGenFencesNV_enc;
8439         this->glIsFenceNV = &glIsFenceNV_enc;
8440         this->glTestFenceNV = &glTestFenceNV_enc;
8441         this->glGetFenceivNV = &glGetFenceivNV_enc;
8442         this->glFinishFenceNV = &glFinishFenceNV_enc;
8443         this->glSetFenceNV = &glSetFenceNV_enc;
8444         this->glGetDriverControlsQCOM = &glGetDriverControlsQCOM_enc;
8445         this->glGetDriverControlStringQCOM = &glGetDriverControlStringQCOM_enc;
8446         this->glEnableDriverControlQCOM = &glEnableDriverControlQCOM_enc;
8447         this->glDisableDriverControlQCOM = &glDisableDriverControlQCOM_enc;
8448         this->glExtGetTexturesQCOM = &glExtGetTexturesQCOM_enc;
8449         this->glExtGetBuffersQCOM = &glExtGetBuffersQCOM_enc;
8450         this->glExtGetRenderbuffersQCOM = &glExtGetRenderbuffersQCOM_enc;
8451         this->glExtGetFramebuffersQCOM = &glExtGetFramebuffersQCOM_enc;
8452         this->glExtGetTexLevelParameterivQCOM = &glExtGetTexLevelParameterivQCOM_enc;
8453         this->glExtTexObjectStateOverrideiQCOM = &glExtTexObjectStateOverrideiQCOM_enc;
8454         this->glExtGetTexSubImageQCOM = &glExtGetTexSubImageQCOM_enc;
8455         this->glExtGetBufferPointervQCOM = (glExtGetBufferPointervQCOM_client_proc_t) &enc_unsupported;
8456         this->glExtGetShadersQCOM = &glExtGetShadersQCOM_enc;
8457         this->glExtGetProgramsQCOM = &glExtGetProgramsQCOM_enc;
8458         this->glExtIsProgramBinaryQCOM = &glExtIsProgramBinaryQCOM_enc;
8459         this->glExtGetProgramBinarySourceQCOM = (glExtGetProgramBinarySourceQCOM_client_proc_t) &enc_unsupported;
8460         this->glStartTilingQCOM = &glStartTilingQCOM_enc;
8461         this->glEndTilingQCOM = &glEndTilingQCOM_enc;
8462 }
8463