system/GLESv1_enc/GLEncoder.cpp

   1 /*
   2 * Copyright (C) 2011 The Android Open Source Project
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16 #include "GLEncoder.h"
  17 #include "glUtils.h"
  18 #include "FixedBuffer.h"
  19 #include <cutils/log.h>
  20 #include <assert.h>
  21
  22 #ifndef MIN
  23 #define MIN(a, b) ((a) < (b) ? (a) : (b))
  24 #endif
  25
  26 static GLubyte *gVendorString= (GLubyte *) "Android";
  27 static GLubyte *gRendererString= (GLubyte *) "Android HW-GLES 1.0";
  28 static GLubyte *gVersionString= (GLubyte *) "OpenGL ES-CM 1.0";
  29 static GLubyte *gExtensionsString= (GLubyte *) "GL_OES_EGL_image_external ";
  30
  31 #define SET_ERROR_IF(condition,err) if((condition)) {                            \
  32         ALOGE("%s:%s:%d GL error 0x%x\n", __FILE__, __FUNCTION__, __LINE__, err); \
  33         ctx->setError(err);                                    \
  34         return;                                                  \
  35     }
  36
  37
  38 #define RET_AND_SET_ERROR_IF(condition,err,ret) if((condition)) {                \
  39         ALOGE("%s:%s:%d GL error 0x%x\n", __FILE__, __FUNCTION__, __LINE__, err); \
  40         ctx->setError(err);                                    \
  41         return ret;                                              \
  42     }
  43
  44 GLenum GLEncoder::s_glGetError(void * self)
  45 {
  46     GLEncoder *ctx = (GLEncoder *)self;
  47     GLenum err = ctx->getError();
  48     if(err != GL_NO_ERROR) {
  49         ctx->setError(GL_NO_ERROR);
  50         return err;
  51     }
  52
  53     return ctx->m_glGetError_enc(self);
  54
  55 }
  56
  57 GLint * GLEncoder::getCompressedTextureFormats()
  58 {
  59     if (m_compressedTextureFormats == NULL) {
  60         this->glGetIntegerv(this, GL_NUM_COMPRESSED_TEXTURE_FORMATS,
  61                             &m_num_compressedTextureFormats);
  62         if (m_num_compressedTextureFormats > 0) {
  63             // get number of texture formats;
  64             m_compressedTextureFormats = new GLint[m_num_compressedTextureFormats];
  65             this->glGetCompressedTextureFormats(this, m_num_compressedTextureFormats, m_compressedTextureFormats);
  66         }
  67     }
  68     return m_compressedTextureFormats;
  69 }
  70
  71 void GLEncoder::s_glGetIntegerv(void *self, GLenum param, GLint *ptr)
  72 {
  73     GLEncoder *ctx = (GLEncoder *)self;
  74     assert(ctx->m_state != NULL);
  75     GLClientState* state = ctx->m_state;
  76
  77     switch (param) {
  78     case GL_COMPRESSED_TEXTURE_FORMATS: {
  79         GLint * compressedTextureFormats = ctx->getCompressedTextureFormats();
  80         if (ctx->m_num_compressedTextureFormats > 0 &&
  81                 compressedTextureFormats != NULL) {
  82             memcpy(ptr, compressedTextureFormats,
  83                    ctx->m_num_compressedTextureFormats * sizeof(GLint));
  84         }
  85         break;
  86     }
  87
  88     case GL_MAX_TEXTURE_UNITS:
  89         ctx->m_glGetIntegerv_enc(self, param, ptr);
  90         *ptr = MIN(*ptr, GLClientState::MAX_TEXTURE_UNITS);
  91         break;
  92
  93     case GL_TEXTURE_BINDING_2D:
  94         *ptr = state->getBoundTexture(GL_TEXTURE_2D);
  95         break;
  96
  97     case GL_TEXTURE_BINDING_EXTERNAL_OES:
  98         *ptr = state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES);
  99         break;
 100
 101     default:
 102         if (!state->getClientStateParameter<GLint>(param,ptr)) {
 103             ctx->m_glGetIntegerv_enc(self, param, ptr);
 104         }
 105         break;
 106     }
 107 }
 108
 109 void GLEncoder::s_glGetFloatv(void *self, GLenum param, GLfloat *ptr)
 110 {
 111     GLEncoder *ctx = (GLEncoder *)self;
 112     assert(ctx->m_state != NULL);
 113     GLClientState* state = ctx->m_state;
 114
 115     switch (param) {
 116     case GL_COMPRESSED_TEXTURE_FORMATS: {
 117         GLint * compressedTextureFormats = ctx->getCompressedTextureFormats();
 118         if (ctx->m_num_compressedTextureFormats > 0 &&
 119                 compressedTextureFormats != NULL) {
 120             for (int i = 0; i < ctx->m_num_compressedTextureFormats; i++) {
 121                 ptr[i] = (GLfloat) compressedTextureFormats[i];
 122             }
 123         }
 124         break;
 125     }
 126
 127     case GL_MAX_TEXTURE_UNITS:
 128         ctx->m_glGetFloatv_enc(self, param, ptr);
 129         *ptr = MIN(*ptr, (GLfloat)GLClientState::MAX_TEXTURE_UNITS);
 130         break;
 131
 132     case GL_TEXTURE_BINDING_2D:
 133         *ptr = (GLfloat)state->getBoundTexture(GL_TEXTURE_2D);
 134         break;
 135
 136     case GL_TEXTURE_BINDING_EXTERNAL_OES:
 137         *ptr = (GLfloat)state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES);
 138         break;
 139
 140     default:
 141         if (!state->getClientStateParameter<GLfloat>(param,ptr)) {
 142             ctx->m_glGetFloatv_enc(self, param, ptr);
 143         }
 144         break;
 145     }
 146 }
 147
 148 void GLEncoder::s_glGetFixedv(void *self, GLenum param, GLfixed *ptr)
 149 {
 150     GLEncoder *ctx = (GLEncoder *)self;
 151     assert(ctx->m_state != NULL);
 152     GLClientState* state = ctx->m_state;
 153
 154     switch (param) {
 155     case GL_COMPRESSED_TEXTURE_FORMATS: {
 156         GLint * compressedTextureFormats = ctx->getCompressedTextureFormats();
 157         if (ctx->m_num_compressedTextureFormats > 0 &&
 158                 compressedTextureFormats != NULL) {
 159             for (int i = 0; i < ctx->m_num_compressedTextureFormats; i++) {
 160                 ptr[i] =  compressedTextureFormats[i] << 16;
 161             }
 162         }
 163         break;
 164     }
 165
 166     case GL_MAX_TEXTURE_UNITS:
 167         ctx->m_glGetFixedv_enc(self, param, ptr);
 168         *ptr = MIN(*ptr, GLClientState::MAX_TEXTURE_UNITS << 16);
 169         break;
 170
 171     case GL_TEXTURE_BINDING_2D:
 172         *ptr = state->getBoundTexture(GL_TEXTURE_2D) << 16;
 173         break;
 174
 175     case GL_TEXTURE_BINDING_EXTERNAL_OES:
 176         *ptr = state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES) << 16;
 177         break;
 178
 179     default:
 180         if (!state->getClientStateParameter<GLfixed>(param,ptr)) {
 181             ctx->m_glGetFixedv_enc(self, param, ptr);
 182         }
 183         break;
 184     }
 185 }
 186
 187 void GLEncoder::s_glGetBooleanv(void *self, GLenum param, GLboolean *ptr)
 188 {
 189     GLEncoder *ctx = (GLEncoder *)self;
 190     assert(ctx->m_state != NULL);
 191     GLClientState* state = ctx->m_state;
 192
 193     switch (param) {
 194     case GL_COMPRESSED_TEXTURE_FORMATS: {
 195         GLint* compressedTextureFormats = ctx->getCompressedTextureFormats();
 196         if (ctx->m_num_compressedTextureFormats > 0 &&
 197                 compressedTextureFormats != NULL) {
 198             for (int i = 0; i < ctx->m_num_compressedTextureFormats; i++) {
 199                 ptr[i] = compressedTextureFormats[i] != 0 ? GL_TRUE : GL_FALSE;
 200             }
 201         }
 202         break;
 203     }
 204
 205     case GL_TEXTURE_BINDING_2D:
 206         *ptr = state->getBoundTexture(GL_TEXTURE_2D) != 0 ? GL_TRUE : GL_FALSE;
 207         break;
 208
 209     case GL_TEXTURE_BINDING_EXTERNAL_OES:
 210         *ptr = state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES) != 0
 211                 ? GL_TRUE : GL_FALSE;
 212         break;
 213
 214     default:
 215         if (!state->getClientStateParameter<GLboolean>(param,ptr)) {
 216             ctx->m_glGetBooleanv_enc(self, param, ptr);
 217         }
 218         break;
 219     }
 220 }
 221
 222 void GLEncoder::s_glGetPointerv(void * self, GLenum param, GLvoid **params)
 223 {
 224     GLEncoder * ctx = (GLEncoder *) self;
 225     assert(ctx->m_state != NULL);
 226     ctx->m_state->getClientStatePointer(param,params);
 227 }
 228
 229 void GLEncoder::s_glFlush(void *self)
 230 {
 231     GLEncoder *ctx = (GLEncoder *)self;
 232     ctx->m_glFlush_enc(self);
 233     ctx->m_stream->flush();
 234 }
 235
 236 const GLubyte *GLEncoder::s_glGetString(void *self, GLenum name)
 237 {
 238     (void)self;
 239
 240     GLubyte *retval =  (GLubyte *) "";
 241     switch(name) {
 242     case GL_VENDOR:
 243         retval = gVendorString;
 244         break;
 245     case GL_RENDERER:
 246         retval = gRendererString;
 247         break;
 248     case GL_VERSION:
 249         retval = gVersionString;
 250         break;
 251     case GL_EXTENSIONS:
 252         retval = gExtensionsString;
 253         break;
 254     }
 255     return retval;
 256 }
 257
 258 void GLEncoder::s_glPixelStorei(void *self, GLenum param, GLint value)
 259 {
 260     GLEncoder *ctx = (GLEncoder *)self;
 261     ctx->m_glPixelStorei_enc(ctx, param, value);
 262     ALOG_ASSERT(ctx->m_state, "GLEncoder::s_glPixelStorei");
 263     ctx->m_state->setPixelStore(param, value);
 264 }
 265
 266 void GLEncoder::s_glVertexPointer(void *self, int size, GLenum type, GLsizei stride, const void *data)
 267 {
 268     GLEncoder *ctx = (GLEncoder *)self;
 269     assert(ctx->m_state != NULL);
 270     ctx->m_state->setState(GLClientState::VERTEX_LOCATION, size, type, false, stride, data);
 271 }
 272
 273 void GLEncoder::s_glNormalPointer(void *self, GLenum type, GLsizei stride, const void *data)
 274 {
 275     GLEncoder *ctx = (GLEncoder *)self;
 276     assert(ctx->m_state != NULL);
 277     ctx->m_state->setState(GLClientState::NORMAL_LOCATION, 3, type, false, stride, data);
 278 }
 279
 280 void GLEncoder::s_glColorPointer(void *self, int size, GLenum type, GLsizei stride, const void *data)
 281 {
 282     GLEncoder *ctx = (GLEncoder *)self;
 283     assert(ctx->m_state != NULL);
 284     ctx->m_state->setState(GLClientState::COLOR_LOCATION, size, type, false, stride, data);
 285 }
 286
 287 void GLEncoder::s_glPointSizePointerOES(void *self, GLenum type, GLsizei stride, const void *data)
 288 {
 289     GLEncoder *ctx = (GLEncoder *)self;
 290     assert(ctx->m_state != NULL);
 291     ctx->m_state->setState(GLClientState::POINTSIZE_LOCATION, 1, type, false, stride, data);
 292 }
 293
 294 void GLEncoder::s_glClientActiveTexture(void *self, GLenum texture)
 295 {
 296     GLEncoder *ctx = (GLEncoder *)self;
 297     assert(ctx->m_state != NULL);
 298     ctx->m_state->setActiveTexture(texture - GL_TEXTURE0);
 299 }
 300
 301 void GLEncoder::s_glTexCoordPointer(void *self, int size, GLenum type, GLsizei stride, const void *data)
 302 {
 303     GLEncoder *ctx = (GLEncoder *)self;
 304     assert(ctx->m_state != NULL);
 305     int loc = ctx->m_state->getLocation(GL_TEXTURE_COORD_ARRAY);
 306     ctx->m_state->setState(loc, size, type, false, stride, data);
 307 }
 308
 309 void GLEncoder::s_glMatrixIndexPointerOES(void *self, int size, GLenum type, GLsizei stride, const void * data)
 310 {
 311     GLEncoder *ctx = (GLEncoder *)self;
 312     assert(ctx->m_state != NULL);
 313     int loc = ctx->m_state->getLocation(GL_MATRIX_INDEX_ARRAY_OES);
 314     ctx->m_state->setState(loc, size, type, false, stride, data);
 315 }
 316
 317 void GLEncoder::s_glWeightPointerOES(void * self, int size, GLenum type, GLsizei stride, const void * data)
 318 {
 319     GLEncoder *ctx = (GLEncoder *)self;
 320     assert(ctx->m_state != NULL);
 321     int loc = ctx->m_state->getLocation(GL_WEIGHT_ARRAY_OES);
 322     ctx->m_state->setState(loc, size, type, false, stride, data);
 323 }
 324
 325 void GLEncoder::s_glEnableClientState(void *self, GLenum state)
 326 {
 327     GLEncoder *ctx = (GLEncoder *) self;
 328     assert(ctx->m_state != NULL);
 329     int loc = ctx->m_state->getLocation(state);
 330     ctx->m_state->enable(loc, 1);
 331 }
 332
 333 void GLEncoder::s_glDisableClientState(void *self, GLenum state)
 334 {
 335     GLEncoder *ctx = (GLEncoder *) self;
 336     assert(ctx->m_state != NULL);
 337     int loc = ctx->m_state->getLocation(state);
 338     ctx->m_state->enable(loc, 0);
 339 }
 340
 341 GLboolean GLEncoder::s_glIsEnabled(void *self, GLenum cap)
 342 {
 343     GLEncoder *ctx = (GLEncoder *) self;
 344     assert(ctx->m_state != NULL);
 345     int loc = ctx->m_state->getLocation(cap);
 346     const GLClientState::VertexAttribState *state = ctx->m_state->getState(loc);
 347
 348     if (state!=NULL)
 349       return state->enabled;
 350
 351     return ctx->m_glIsEnabled_enc(self,cap);
 352 }
 353
 354 void GLEncoder::s_glBindBuffer(void *self, GLenum target, GLuint id)
 355 {
 356     GLEncoder *ctx = (GLEncoder *) self;
 357     assert(ctx->m_state != NULL);
 358     ctx->m_state->bindBuffer(target, id);
 359     // TODO set error state if needed;
 360     ctx->m_glBindBuffer_enc(self, target, id);
 361 }
 362
 363 void GLEncoder::s_glBufferData(void * self, GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage)
 364 {
 365     GLEncoder *ctx = (GLEncoder *) self;
 366     GLuint bufferId = ctx->m_state->getBuffer(target);
 367     SET_ERROR_IF(bufferId==0, GL_INVALID_OPERATION);
 368     SET_ERROR_IF(size<0, GL_INVALID_VALUE);
 369
 370     ctx->m_shared->updateBufferData(bufferId, size, (void*)data);
 371     ctx->m_glBufferData_enc(self, target, size, data, usage);
 372 }
 373
 374 void GLEncoder::s_glBufferSubData(void * self, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data)
 375 {
 376     GLEncoder *ctx = (GLEncoder *) self;
 377     GLuint bufferId = ctx->m_state->getBuffer(target);
 378     SET_ERROR_IF(bufferId==0, GL_INVALID_OPERATION);
 379
 380     GLenum res = ctx->m_shared->subUpdateBufferData(bufferId, offset, size, (void*)data);
 381     SET_ERROR_IF(res, res);
 382
 383     ctx->m_glBufferSubData_enc(self, target, offset, size, data);
 384 }
 385
 386 void GLEncoder::s_glDeleteBuffers(void * self, GLsizei n, const GLuint * buffers)
 387 {
 388     GLEncoder *ctx = (GLEncoder *) self;
 389     SET_ERROR_IF(n<0, GL_INVALID_VALUE);
 390     for (int i=0; i<n; i++) {
 391         ctx->m_shared->deleteBufferData(buffers[i]);
 392         ctx->m_glDeleteBuffers_enc(self,1,&buffers[i]);
 393     }
 394 }
 395
 396 void GLEncoder::sendVertexData(unsigned int first, unsigned int count)
 397 {
 398     assert(m_state != NULL);
 399     GLenum prevActiveTexUnit = m_state->getActiveTextureUnit();
 400     for (int i = 0; i < GLClientState::LAST_LOCATION; i++) {
 401         bool enableDirty;
 402         const GLClientState::VertexAttribState *state = m_state->getStateAndEnableDirty(i, &enableDirty);
 403
 404         // do not process if state not valid
 405         if (!state) continue;
 406
 407         // do not send disable state if state was already disabled
 408         if (!enableDirty && !state->enabled) continue;
 409
 410         if ( i >= GLClientState::TEXCOORD0_LOCATION &&
 411             i <= GLClientState::TEXCOORD7_LOCATION ) {
 412             m_glClientActiveTexture_enc(this, GL_TEXTURE0 + i - GLClientState::TEXCOORD0_LOCATION);
 413         }
 414
 415         if (state->enabled) {
 416             if (enableDirty)
 417                 m_glEnableClientState_enc(this, state->glConst);
 418
 419             unsigned int datalen = state->elementSize * count;
 420             int stride = state->stride;
 421             if (stride == 0) stride = state->elementSize;
 422             int firstIndex = stride * first;
 423
 424             this->m_glBindBuffer_enc(this, GL_ARRAY_BUFFER, state->bufferObject);
 425             if (state->bufferObject == 0) {
 426
 427                 switch(i) {
 428                 case GLClientState::VERTEX_LOCATION:
 429                     this->glVertexPointerData(this, state->size, state->type, state->stride,
 430                                               (unsigned char *)state->data + firstIndex, datalen);
 431                     break;
 432                 case GLClientState::NORMAL_LOCATION:
 433                     this->glNormalPointerData(this, state->type, state->stride,
 434                                               (unsigned char *)state->data + firstIndex, datalen);
 435                     break;
 436                 case GLClientState::COLOR_LOCATION:
 437                     this->glColorPointerData(this, state->size, state->type, state->stride,
 438                                              (unsigned char *)state->data + firstIndex, datalen);
 439                     break;
 440                 case GLClientState::TEXCOORD0_LOCATION:
 441                 case GLClientState::TEXCOORD1_LOCATION:
 442                 case GLClientState::TEXCOORD2_LOCATION:
 443                 case GLClientState::TEXCOORD3_LOCATION:
 444                 case GLClientState::TEXCOORD4_LOCATION:
 445                 case GLClientState::TEXCOORD5_LOCATION:
 446                 case GLClientState::TEXCOORD6_LOCATION:
 447                 case GLClientState::TEXCOORD7_LOCATION:
 448                     m_state->setActiveTextureUnit(i - GLClientState::TEXCOORD0_LOCATION + GL_TEXTURE0);
 449                     if (m_state->getPriorityEnabledTarget(GL_INVALID_ENUM) != GL_INVALID_ENUM) {
 450                         this->glTexCoordPointerData(this, i - GLClientState::TEXCOORD0_LOCATION, state->size, state->type, state->stride,
 451                                                 (unsigned char *)state->data + firstIndex, datalen);
 452                     }
 453                     break;
 454                 case GLClientState::POINTSIZE_LOCATION:
 455                     this->glPointSizePointerData(this, state->type, state->stride,
 456                                                  (unsigned char *) state->data + firstIndex, datalen);
 457                     break;
 458                 case GLClientState::WEIGHT_LOCATION:
 459                     this->glWeightPointerData(this, state->size, state->type, state->stride,
 460                                               (unsigned char * ) state->data + firstIndex, datalen);
 461                     break;
 462                 case GLClientState::MATRIXINDEX_LOCATION:
 463                     this->glMatrixIndexPointerData(this, state->size, state->type, state->stride,
 464                                                   (unsigned char *)state->data + firstIndex, datalen);
 465                     break;
 466                 }
 467             } else {
 468
 469                 switch(i) {
 470                 case GLClientState::VERTEX_LOCATION:
 471                     this->glVertexPointerOffset(this, state->size, state->type, state->stride,
 472                                                 (uintptr_t)state->data + firstIndex);
 473                     break;
 474                 case GLClientState::NORMAL_LOCATION:
 475                     this->glNormalPointerOffset(this, state->type, state->stride,
 476                                                 (uintptr_t)state->data + firstIndex);
 477                     break;
 478                 case GLClientState::POINTSIZE_LOCATION:
 479                     this->glPointSizePointerOffset(this, state->type, state->stride,
 480                                                    (uintptr_t)state->data + firstIndex);
 481                     break;
 482                 case GLClientState::COLOR_LOCATION:
 483                     this->glColorPointerOffset(this, state->size, state->type, state->stride,
 484                                                (uintptr_t)state->data + firstIndex);
 485                     break;
 486                 case GLClientState::TEXCOORD0_LOCATION:
 487                 case GLClientState::TEXCOORD1_LOCATION:
 488                 case GLClientState::TEXCOORD2_LOCATION:
 489                 case GLClientState::TEXCOORD3_LOCATION:
 490                 case GLClientState::TEXCOORD4_LOCATION:
 491                 case GLClientState::TEXCOORD5_LOCATION:
 492                 case GLClientState::TEXCOORD6_LOCATION:
 493                 case GLClientState::TEXCOORD7_LOCATION:
 494                     this->glTexCoordPointerOffset(this, state->size, state->type, state->stride,
 495                                                   (uintptr_t)state->data + firstIndex);
 496                     break;
 497                 case GLClientState::WEIGHT_LOCATION:
 498                     this->glWeightPointerOffset(this,state->size,state->type,state->stride,
 499                                                 (uintptr_t)state->data+firstIndex);
 500                     break;
 501                 case GLClientState::MATRIXINDEX_LOCATION:
 502                     this->glMatrixIndexPointerOffset(this,state->size,state->type,state->stride,
 503                                               (uintptr_t)state->data+firstIndex);
 504                     break;
 505                 }
 506             }
 507             this->m_glBindBuffer_enc(this, GL_ARRAY_BUFFER, m_state->currentArrayVbo());
 508         } else {
 509             this->m_glDisableClientState_enc(this, state->glConst);
 510         }
 511     }
 512     m_state->setActiveTextureUnit(prevActiveTexUnit);
 513 }
 514
 515 void GLEncoder::s_glDrawArrays(void *self, GLenum mode, GLint first, GLsizei count)
 516 {
 517     GLEncoder *ctx = (GLEncoder *)self;
 518
 519     bool has_arrays = false;
 520     for (int i = 0; i < GLClientState::LAST_LOCATION; i++) {
 521         const GLClientState::VertexAttribState *state = ctx->m_state->getState(i);
 522         if (state->enabled) {
 523             if (state->bufferObject || state->data) {
 524                 has_arrays = true;
 525             } else {
 526                 ALOGE("glDrawArrays: a vertex attribute array is enabled with no data bound\n");
 527                 ctx->setError(GL_INVALID_OPERATION);
 528                 return;
 529             }
 530         }
 531     }
 532     if (!has_arrays) {
 533         ALOGE("glDrawArrays: no data bound to the command - ignoring\n");
 534         return;
 535     }
 536
 537     ctx->sendVertexData(first, count);
 538     ctx->m_glDrawArrays_enc(ctx, mode, /*first*/ 0, count);
 539     ctx->m_stream->flush();
 540 }
 541
 542 void GLEncoder::s_glDrawElements(void *self, GLenum mode, GLsizei count, GLenum type, const void *indices)
 543 {
 544
 545     GLEncoder *ctx = (GLEncoder *)self;
 546     assert(ctx->m_state != NULL);
 547     SET_ERROR_IF(count<0, GL_INVALID_VALUE);
 548
 549     bool has_immediate_arrays = false;
 550     bool has_indirect_arrays = false;
 551
 552     for (int i = 0; i < GLClientState::LAST_LOCATION; i++) {
 553         const GLClientState::VertexAttribState *state = ctx->m_state->getState(i);
 554         if (state->enabled) {
 555             if (state->bufferObject != 0) {
 556                 has_indirect_arrays = true;
 557             } else if (state->data) {
 558                 has_immediate_arrays = true;
 559             } else {
 560                 ALOGE("glDrawElements: a vertex attribute array is enabled with no data bound\n");
 561                 ctx->setError(GL_INVALID_OPERATION);
 562                 return;
 563             }
 564         }
 565     }
 566
 567     if (!has_immediate_arrays && !has_indirect_arrays) {
 568         ALOGE("glDrawElements: no data bound to the command - ignoring\n");
 569         return;
 570     }
 571
 572     bool adjustIndices = true;
 573     if (ctx->m_state->currentIndexVbo() != 0) {
 574         if (!has_immediate_arrays) {
 575             ctx->sendVertexData(0, count);
 576             ctx->m_glBindBuffer_enc(self, GL_ELEMENT_ARRAY_BUFFER, ctx->m_state->currentIndexVbo());
 577             ctx->glDrawElementsOffset(ctx, mode, count, type, (uintptr_t)indices);
 578             ctx->m_stream->flush();
 579             adjustIndices = false;
 580         } else {
 581             BufferData * buf = ctx->m_shared->getBufferData(ctx->m_state->currentIndexVbo());
 582             ctx->m_glBindBuffer_enc(self, GL_ELEMENT_ARRAY_BUFFER, 0);
 583             indices = (void*)((GLintptr)buf->m_fixedBuffer.ptr() + (GLintptr)indices);
 584         }
 585     }
 586     if (adjustIndices) {
 587         void *adjustedIndices = (void*)indices;
 588         int minIndex = 0, maxIndex = 0;
 589
 590         switch(type) {
 591         case GL_BYTE:
 592         case GL_UNSIGNED_BYTE:
 593             GLUtils::minmax<unsigned char>((unsigned char *)indices, count, &minIndex, &maxIndex);
 594             if (minIndex != 0) {
 595                 adjustedIndices =  ctx->m_fixedBuffer.alloc(glSizeof(type) * count);
 596                 GLUtils::shiftIndices<unsigned char>((unsigned char *)indices,
 597                                                  (unsigned char *)adjustedIndices,
 598                                                  count, -minIndex);
 599             }
 600             break;
 601         case GL_SHORT:
 602         case GL_UNSIGNED_SHORT:
 603             GLUtils::minmax<unsigned short>((unsigned short *)indices, count, &minIndex, &maxIndex);
 604             if (minIndex != 0) {
 605                 adjustedIndices = ctx->m_fixedBuffer.alloc(glSizeof(type) * count);
 606                 GLUtils::shiftIndices<unsigned short>((unsigned short *)indices,
 607                                                  (unsigned short *)adjustedIndices,
 608                                                  count, -minIndex);
 609             }
 610             break;
 611         case GL_INT:
 612         case GL_UNSIGNED_INT:
 613             GLUtils::minmax<unsigned int>((unsigned int *)indices, count, &minIndex, &maxIndex);
 614             if (minIndex != 0) {
 615                 adjustedIndices = ctx->m_fixedBuffer.alloc(glSizeof(type) * count);
 616                 GLUtils::shiftIndices<unsigned int>((unsigned int *)indices,
 617                                                  (unsigned int *)adjustedIndices,
 618                                                  count, -minIndex);
 619             }
 620             break;
 621         default:
 622             ALOGE("unsupported index buffer type %d\n", type);
 623         }
 624         if (has_indirect_arrays || 1) {
 625             ctx->sendVertexData(minIndex, maxIndex - minIndex + 1);
 626             ctx->glDrawElementsData(ctx, mode, count, type, adjustedIndices,
 627                                       count * glSizeof(type));
 628             ctx->m_stream->flush();
 629             // XXX - OPTIMIZATION (see the other else branch) should be implemented
 630             if(!has_indirect_arrays) {
 631                 //ALOGD("unoptimized drawelements !!!\n");
 632             }
 633         } else {
 634             // we are all direct arrays and immidate mode index array -
 635             // rebuild the arrays and the index array;
 636             ALOGE("glDrawElements: direct index & direct buffer data - will be implemented in later versions;\n");
 637         }
 638     }
 639 }
 640
 641 void GLEncoder::s_glActiveTexture(void* self, GLenum texture)
 642 {
 643     GLEncoder* ctx = (GLEncoder*)self;
 644     GLClientState* state = ctx->m_state;
 645     GLenum err;
 646
 647     if ((err = state->setActiveTextureUnit(texture)) != GL_NO_ERROR) {
 648         ALOGE("%s:%s:%d GL error %#x\n", __FILE__, __FUNCTION__, __LINE__, err);
 649         ctx->setError(err);
 650         return;
 651     }
 652
 653     ctx->m_glActiveTexture_enc(ctx, texture);
 654 }
 655
 656 void GLEncoder::s_glBindTexture(void* self, GLenum target, GLuint texture)
 657 {
 658     GLEncoder* ctx = (GLEncoder*)self;
 659     GLClientState* state = ctx->m_state;
 660     GLenum err;
 661
 662     GLboolean firstUse;
 663     if ((err = state->bindTexture(target, texture, &firstUse)) != GL_NO_ERROR) {
 664         ALOGE("%s:%s:%d GL error %#x\n", __FILE__, __FUNCTION__, __LINE__, err);
 665         ctx->setError(err);
 666         return;
 667     }
 668
 669     if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES) {
 670         ctx->m_glBindTexture_enc(ctx, target, texture);
 671         return;
 672     }
 673
 674     GLenum priorityTarget = state->getPriorityEnabledTarget(GL_TEXTURE_2D);
 675
 676     if (target == GL_TEXTURE_EXTERNAL_OES && firstUse) {
 677         // set TEXTURE_EXTERNAL_OES default states which differ from TEXTURE_2D
 678         ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D, texture);
 679         ctx->m_glTexParameteri_enc(ctx, GL_TEXTURE_2D,
 680                 GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 681         ctx->m_glTexParameteri_enc(ctx, GL_TEXTURE_2D,
 682                 GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 683         ctx->m_glTexParameteri_enc(ctx, GL_TEXTURE_2D,
 684                 GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 685
 686         if (target != priorityTarget) {
 687             ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D,
 688                     state->getBoundTexture(GL_TEXTURE_2D));
 689         }
 690     }
 691
 692     if (target == priorityTarget) {
 693         ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D, texture);
 694     }
 695 }
 696
 697 void GLEncoder::s_glDeleteTextures(void* self, GLsizei n, const GLuint* textures)
 698 {
 699     GLEncoder* ctx = (GLEncoder*)self;
 700     GLClientState* state = ctx->m_state;
 701
 702     state->deleteTextures(n, textures);
 703     ctx->m_glDeleteTextures_enc(ctx, n, textures);
 704 }
 705
 706 void GLEncoder::s_glDisable(void* self, GLenum cap)
 707 {
 708     GLEncoder* ctx = (GLEncoder*)self;
 709     GLClientState* state = ctx->m_state;
 710
 711     if (cap == GL_TEXTURE_2D || cap == GL_TEXTURE_EXTERNAL_OES) {
 712         GLenum prevTarget = state->getPriorityEnabledTarget(GL_INVALID_ENUM);
 713         state->disableTextureTarget(cap);
 714         GLenum currTarget = state->getPriorityEnabledTarget(GL_INVALID_ENUM);
 715
 716         if (prevTarget != currTarget) {
 717             if (currTarget == GL_INVALID_ENUM) {
 718                 ctx->m_glDisable_enc(ctx, GL_TEXTURE_2D);
 719                 currTarget = GL_TEXTURE_2D;
 720             }
 721             // maintain the invariant that when TEXTURE_EXTERNAL_OES is
 722             // disabled, the TEXTURE_2D binding is active, even if
 723             // TEXTURE_2D is also disabled.
 724             ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D,
 725                     state->getBoundTexture(currTarget));
 726         }
 727
 728     } else {
 729         ctx->m_glDisable_enc(ctx, cap);
 730     }
 731 }
 732
 733 void GLEncoder::s_glEnable(void* self, GLenum cap)
 734 {
 735     GLEncoder* ctx = (GLEncoder*)self;
 736     GLClientState* state = ctx->m_state;
 737
 738     if (cap == GL_TEXTURE_2D || cap == GL_TEXTURE_EXTERNAL_OES) {
 739         GLenum prevTarget = state->getPriorityEnabledTarget(GL_INVALID_ENUM);
 740         state->enableTextureTarget(cap);
 741         GLenum currTarget = state->getPriorityEnabledTarget(GL_INVALID_ENUM);
 742
 743         if (prevTarget != currTarget) {
 744             if (prevTarget == GL_INVALID_ENUM) {
 745                 ctx->m_glEnable_enc(ctx, GL_TEXTURE_2D);
 746             }
 747             if (currTarget == GL_TEXTURE_EXTERNAL_OES) {
 748                 ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D,
 749                         state->getBoundTexture(currTarget));
 750             }
 751         }
 752
 753     } else {
 754         ctx->m_glEnable_enc(ctx, cap);
 755     }
 756 }
 757
 758 void GLEncoder::s_glGetTexParameterfv(void* self,
 759         GLenum target, GLenum pname, GLfloat* params)
 760 {
 761     GLEncoder* ctx = (GLEncoder*)self;
 762     const GLClientState* state = ctx->m_state;
 763
 764     if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) {
 765         ctx->override2DTextureTarget(target);
 766         ctx->m_glGetTexParameterfv_enc(ctx, GL_TEXTURE_2D, pname, params);
 767         ctx->restore2DTextureTarget();
 768     } else {
 769         ctx->m_glGetTexParameterfv_enc(ctx, target, pname, params);
 770     }
 771 }
 772
 773 void GLEncoder::s_glGetTexParameteriv(void* self,
 774         GLenum target, GLenum pname, GLint* params)
 775 {
 776     GLEncoder* ctx = (GLEncoder*)self;
 777     const GLClientState* state = ctx->m_state;
 778
 779     switch (pname) {
 780     case GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES:
 781         *params = 1;
 782         break;
 783
 784     default:
 785         if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) {
 786             ctx->override2DTextureTarget(target);
 787             ctx->m_glGetTexParameteriv_enc(ctx, GL_TEXTURE_2D, pname, params);
 788             ctx->restore2DTextureTarget();
 789         } else {
 790             ctx->m_glGetTexParameteriv_enc(ctx, target, pname, params);
 791         }
 792         break;
 793     }
 794 }
 795
 796 void GLEncoder::s_glGetTexParameterxv(void* self,
 797         GLenum target, GLenum pname, GLfixed* params)
 798 {
 799     GLEncoder* ctx = (GLEncoder*)self;
 800     const GLClientState* state = ctx->m_state;
 801
 802     if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) {
 803         ctx->override2DTextureTarget(target);
 804         ctx->m_glGetTexParameterxv_enc(ctx, GL_TEXTURE_2D, pname, params);
 805         ctx->restore2DTextureTarget();
 806     } else {
 807         ctx->m_glGetTexParameterxv_enc(ctx, target, pname, params);
 808     }
 809 }
 810
 811 static bool isValidTextureExternalParam(GLenum pname, GLenum param)
 812 {
 813     switch (pname) {
 814     case GL_TEXTURE_MIN_FILTER:
 815     case GL_TEXTURE_MAG_FILTER:
 816         return param == GL_NEAREST || param == GL_LINEAR;
 817
 818     case GL_TEXTURE_WRAP_S:
 819     case GL_TEXTURE_WRAP_T:
 820         return param == GL_CLAMP_TO_EDGE;
 821
 822     case GL_GENERATE_MIPMAP:
 823         return param == GL_FALSE;
 824
 825     default:
 826         return true;
 827     }
 828 }
 829
 830 void GLEncoder::s_glTexParameterf(void* self,
 831         GLenum target, GLenum pname, GLfloat param)
 832 {
 833     GLEncoder* ctx = (GLEncoder*)self;
 834     const GLClientState* state = ctx->m_state;
 835
 836     SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES &&
 837             !isValidTextureExternalParam(pname, (GLenum)param)),
 838             GL_INVALID_ENUM);
 839
 840     if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) {
 841         ctx->override2DTextureTarget(target);
 842         ctx->m_glTexParameterf_enc(ctx, GL_TEXTURE_2D, pname, param);
 843         ctx->restore2DTextureTarget();
 844     } else {
 845         ctx->m_glTexParameterf_enc(ctx, target, pname, param);
 846     }
 847 }
 848
 849 void GLEncoder::s_glTexParameterfv(void* self,
 850         GLenum target, GLenum pname, const GLfloat* params)
 851 {
 852     GLEncoder* ctx = (GLEncoder*)self;
 853     const GLClientState* state = ctx->m_state;
 854
 855     SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES &&
 856             !isValidTextureExternalParam(pname, (GLenum)params[0])),
 857             GL_INVALID_ENUM);
 858
 859     if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) {
 860         ctx->override2DTextureTarget(target);
 861         ctx->m_glTexParameterfv_enc(ctx, GL_TEXTURE_2D, pname, params);
 862         ctx->restore2DTextureTarget();
 863     } else {
 864         ctx->m_glTexParameterfv_enc(ctx, target, pname, params);
 865     }
 866 }
 867
 868 void GLEncoder::s_glTexParameteri(void* self,
 869         GLenum target, GLenum pname, GLint param)
 870 {
 871     GLEncoder* ctx = (GLEncoder*)self;
 872     const GLClientState* state = ctx->m_state;
 873
 874     SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES &&
 875             !isValidTextureExternalParam(pname, (GLenum)param)),
 876             GL_INVALID_ENUM);
 877
 878     if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) {
 879         ctx->override2DTextureTarget(target);
 880         ctx->m_glTexParameteri_enc(ctx, GL_TEXTURE_2D, pname, param);
 881         ctx->restore2DTextureTarget();
 882     } else {
 883         ctx->m_glTexParameteri_enc(ctx, target, pname, param);
 884     }
 885 }
 886
 887 void GLEncoder::s_glTexParameterx(void* self,
 888         GLenum target, GLenum pname, GLfixed param)
 889 {
 890     GLEncoder* ctx = (GLEncoder*)self;
 891     const GLClientState* state = ctx->m_state;
 892
 893     SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES &&
 894             !isValidTextureExternalParam(pname, (GLenum)param)),
 895             GL_INVALID_ENUM);
 896
 897     if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) {
 898         ctx->override2DTextureTarget(target);
 899         ctx->m_glTexParameterx_enc(ctx, GL_TEXTURE_2D, pname, param);
 900         ctx->restore2DTextureTarget();
 901     } else {
 902         ctx->m_glTexParameterx_enc(ctx, target, pname, param);
 903     }
 904 }
 905
 906 void GLEncoder::s_glTexParameteriv(void* self,
 907         GLenum target, GLenum pname, const GLint* params)
 908 {
 909     GLEncoder* ctx = (GLEncoder*)self;
 910     const GLClientState* state = ctx->m_state;
 911
 912     SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES &&
 913             !isValidTextureExternalParam(pname, (GLenum)params[0])),
 914             GL_INVALID_ENUM);
 915
 916     if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) {
 917         ctx->override2DTextureTarget(target);
 918         ctx->m_glTexParameteriv_enc(ctx, GL_TEXTURE_2D, pname, params);
 919         ctx->restore2DTextureTarget();
 920     } else {
 921         ctx->m_glTexParameteriv_enc(ctx, target, pname, params);
 922     }
 923 }
 924
 925 void GLEncoder::s_glTexParameterxv(void* self,
 926         GLenum target, GLenum pname, const GLfixed* params)
 927 {
 928     GLEncoder* ctx = (GLEncoder*)self;
 929     const GLClientState* state = ctx->m_state;
 930
 931     SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES &&
 932             !isValidTextureExternalParam(pname, (GLenum)params[0])),
 933             GL_INVALID_ENUM);
 934
 935     if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) {
 936         ctx->override2DTextureTarget(target);
 937         ctx->m_glTexParameterxv_enc(ctx, GL_TEXTURE_2D, pname, params);
 938         ctx->restore2DTextureTarget();
 939     } else {
 940         ctx->m_glTexParameterxv_enc(ctx, target, pname, params);
 941     }
 942 }
 943
 944 void GLEncoder::override2DTextureTarget(GLenum target)
 945 {
 946     if ((target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) &&
 947         target != m_state->getPriorityEnabledTarget(GL_TEXTURE_2D)) {
 948             m_glBindTexture_enc(this, GL_TEXTURE_2D,
 949                     m_state->getBoundTexture(target));
 950     }
 951 }
 952
 953 void GLEncoder::restore2DTextureTarget()
 954 {
 955     GLenum priorityTarget = m_state->getPriorityEnabledTarget(GL_TEXTURE_2D);
 956     m_glBindTexture_enc(this, GL_TEXTURE_2D,
 957             m_state->getBoundTexture(priorityTarget));
 958 }
 959
 960 void GLEncoder::s_glGenFramebuffersOES(void* self,
 961         GLsizei n, GLuint* framebuffers) {
 962     GLEncoder* ctx = (GLEncoder*)self;
 963     GLClientState* state = ctx->m_state;
 964
 965     SET_ERROR_IF(n < 0, GL_INVALID_VALUE);
 966
 967     ctx->m_glGenFramebuffersOES_enc(self, n, framebuffers);
 968     state->addFramebuffers(n, framebuffers);
 969 }
 970
 971 void GLEncoder::s_glDeleteFramebuffersOES(void* self,
 972         GLsizei n, const GLuint* framebuffers) {
 973     GLEncoder* ctx = (GLEncoder*)self;
 974     GLClientState* state = ctx->m_state;
 975
 976     SET_ERROR_IF(n < 0, GL_INVALID_VALUE);
 977
 978     ctx->m_glDeleteFramebuffersOES_enc(self, n, framebuffers);
 979     state->removeFramebuffers(n, framebuffers);
 980 }
 981
 982 void GLEncoder::s_glBindFramebufferOES(void* self,
 983         GLenum target, GLuint framebuffer) {
 984     GLEncoder* ctx = (GLEncoder*)self;
 985     GLClientState* state = ctx->m_state;
 986
 987     SET_ERROR_IF((target != GL_FRAMEBUFFER),
 988                  GL_INVALID_ENUM);
 989
 990     state->bindFramebuffer(target, framebuffer);
 991
 992     ctx->m_glBindFramebufferOES_enc(self, target, framebuffer);
 993 }
 994
 995 void GLEncoder::s_glFramebufferTexture2DOES(void*self,
 996         GLenum target, GLenum attachment,
 997         GLenum textarget, GLuint texture, GLint level) {
 998     GLEncoder* ctx = (GLEncoder*)self;
 999     GLClientState* state = ctx->m_state;
1000
1001     state->attachTextureObject(attachment, texture);
1002
1003     ctx->m_glFramebufferTexture2DOES_enc(self, target, attachment, textarget, texture, level);
1004 }
1005
1006 void GLEncoder::s_glFramebufferTexture2DMultisampleIMG(void* self,
1007         GLenum target, GLenum attachment,
1008         GLenum textarget, GLuint texture, GLint level, GLsizei samples) {
1009     GLEncoder* ctx = (GLEncoder*)self;
1010     GLClientState* state = ctx->m_state;
1011
1012     state->attachTextureObject(attachment, texture);
1013
1014     ctx->m_glFramebufferTexture2DMultisampleIMG_enc(self, target, attachment, textarget, texture, level, samples);
1015 }
1016
1017 void GLEncoder::s_glGetFramebufferAttachmentParameterivOES(void* self,
1018         GLenum target, GLenum attachment, GLenum pname, GLint* params)
1019 {
1020     GLEncoder* ctx = (GLEncoder*)self;
1021     const GLClientState* state = ctx->m_state;
1022
1023     SET_ERROR_IF(state->boundFramebuffer() == 0,
1024                  GL_INVALID_OPERATION);
1025     SET_ERROR_IF((pname != GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE) &&
1026                  (!state->attachmentHasObject(attachment)),
1027                  GL_INVALID_ENUM);
1028
1029     ctx->m_glGetFramebufferAttachmentParameterivOES_enc(self, target, attachment, pname, params);
1030 }
1031
1032 GLEncoder::GLEncoder(IOStream *stream, ChecksumCalculator *protocol)
1033         : gl_encoder_context_t(stream, protocol)
1034 {
1035     m_initialized = false;
1036     m_state = NULL;
1037     m_error = GL_NO_ERROR;
1038     m_num_compressedTextureFormats = 0;
1039     m_compressedTextureFormats = NULL;
1040
1041     // overrides;
1042 #define OVERRIDE(name)  m_##name##_enc = this-> name ; this-> name = &s_##name
1043
1044     OVERRIDE(glFlush);
1045     OVERRIDE(glPixelStorei);
1046     OVERRIDE(glVertexPointer);
1047     OVERRIDE(glNormalPointer);
1048     OVERRIDE(glColorPointer);
1049     OVERRIDE(glPointSizePointerOES);
1050     OVERRIDE(glClientActiveTexture);
1051     OVERRIDE(glTexCoordPointer);
1052     OVERRIDE(glMatrixIndexPointerOES);
1053     OVERRIDE(glWeightPointerOES);
1054
1055     OVERRIDE(glGetIntegerv);
1056     OVERRIDE(glGetFloatv);
1057     OVERRIDE(glGetBooleanv);
1058     OVERRIDE(glGetFixedv);
1059     OVERRIDE(glGetPointerv);
1060
1061     OVERRIDE(glBindBuffer);
1062     OVERRIDE(glBufferData);
1063     OVERRIDE(glBufferSubData);
1064     OVERRIDE(glDeleteBuffers);
1065
1066     OVERRIDE(glEnableClientState);
1067     OVERRIDE(glDisableClientState);
1068     OVERRIDE(glIsEnabled);
1069     OVERRIDE(glDrawArrays);
1070     OVERRIDE(glDrawElements);
1071
1072     this->glGetString = s_glGetString;
1073     this->glFinish = s_glFinish;
1074
1075     OVERRIDE(glGetError);
1076
1077     OVERRIDE(glActiveTexture);
1078     OVERRIDE(glBindTexture);
1079     OVERRIDE(glDeleteTextures);
1080     OVERRIDE(glDisable);
1081     OVERRIDE(glEnable);
1082     OVERRIDE(glGetTexParameterfv);
1083     OVERRIDE(glGetTexParameteriv);
1084     OVERRIDE(glGetTexParameterxv);
1085     OVERRIDE(glTexParameterf);
1086     OVERRIDE(glTexParameterfv);
1087     OVERRIDE(glTexParameteri);
1088     OVERRIDE(glTexParameterx);
1089     OVERRIDE(glTexParameteriv);
1090     OVERRIDE(glTexParameterxv);
1091
1092     OVERRIDE(glGenFramebuffersOES);
1093     OVERRIDE(glDeleteFramebuffersOES);
1094     OVERRIDE(glBindFramebufferOES);
1095     OVERRIDE(glFramebufferTexture2DOES);
1096     OVERRIDE(glFramebufferTexture2DMultisampleIMG);
1097     OVERRIDE(glGetFramebufferAttachmentParameterivOES);
1098 }
1099
1100 GLEncoder::~GLEncoder()
1101 {
1102     delete [] m_compressedTextureFormats;
1103 }
1104
1105 size_t GLEncoder::pixelDataSize(GLsizei width, GLsizei height, GLenum format, GLenum type, int pack)
1106 {
1107     assert(m_state != NULL);
1108     return m_state->pixelDataSize(width, height, format, type, pack);
1109 }
1110
1111 void GLEncoder::s_glFinish(void *self)
1112 {
1113     GLEncoder *ctx = (GLEncoder *)self;
1114     ctx->glFinishRoundTrip(self);
1115 }