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->setVertexAttribState(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->setVertexAttribState(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->setVertexAttribState(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->setVertexAttribState(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->setVertexAttribState(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->setVertexAttribState(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->setVertexAttribState(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 return state.enabled; 348 } 349 350 void GLEncoder::s_glBindBuffer(void *self, GLenum target, GLuint id) 351 { 352 GLEncoder *ctx = (GLEncoder *) self; 353 assert(ctx->m_state != NULL); 354 ctx->m_state->bindBuffer(target, id); 355 // TODO set error state if needed; 356 ctx->m_glBindBuffer_enc(self, target, id); 357 } 358 359 void GLEncoder::s_glBufferData(void * self, GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage) 360 { 361 GLEncoder *ctx = (GLEncoder *) self; 362 GLuint bufferId = ctx->m_state->getBuffer(target); 363 SET_ERROR_IF(bufferId==0, GL_INVALID_OPERATION); 364 SET_ERROR_IF(size<0, GL_INVALID_VALUE); 365 366 ctx->m_shared->updateBufferData(bufferId, size, (void*)data); 367 ctx->m_glBufferData_enc(self, target, size, data, usage); 368 } 369 370 void GLEncoder::s_glBufferSubData(void * self, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data) 371 { 372 GLEncoder *ctx = (GLEncoder *) self; 373 GLuint bufferId = ctx->m_state->getBuffer(target); 374 SET_ERROR_IF(bufferId==0, GL_INVALID_OPERATION); 375 376 GLenum res = ctx->m_shared->subUpdateBufferData(bufferId, offset, size, (void*)data); 377 SET_ERROR_IF(res, res); 378 379 ctx->m_glBufferSubData_enc(self, target, offset, size, data); 380 } 381 382 void GLEncoder::s_glDeleteBuffers(void * self, GLsizei n, const GLuint * buffers) 383 { 384 GLEncoder *ctx = (GLEncoder *) self; 385 SET_ERROR_IF(n<0, GL_INVALID_VALUE); 386 for (int i=0; i<n; i++) { 387 ctx->m_shared->deleteBufferData(buffers[i]); 388 ctx->m_glDeleteBuffers_enc(self,1,&buffers[i]); 389 } 390 } 391 392 void GLEncoder::sendVertexData(unsigned int first, unsigned int count) 393 { 394 assert(m_state != NULL); 395 GLenum prevActiveTexUnit = m_state->getActiveTextureUnit(); 396 for (int i = 0; i < GLClientState::LAST_LOCATION; i++) { 397 bool enableDirty; 398 const GLClientState::VertexAttribState& state = m_state->getStateAndEnableDirty(i, &enableDirty); 399 400 // do not send disable state if state was already disabled 401 if (!enableDirty && !state.enabled) continue; 402 403 if ( i >= GLClientState::TEXCOORD0_LOCATION && 404 i <= GLClientState::TEXCOORD7_LOCATION ) { 405 m_glClientActiveTexture_enc(this, GL_TEXTURE0 + i - GLClientState::TEXCOORD0_LOCATION); 406 } 407 408 if (state.enabled) { 409 if (enableDirty) 410 m_glEnableClientState_enc(this, state.glConst); 411 412 unsigned int datalen = state.elementSize * count; 413 int stride = state.stride; 414 if (stride == 0) stride = state.elementSize; 415 int firstIndex = stride * first; 416 417 this->m_glBindBuffer_enc(this, GL_ARRAY_BUFFER, state.bufferObject); 418 if (state.bufferObject == 0) { 419 420 switch(i) { 421 case GLClientState::VERTEX_LOCATION: 422 this->glVertexPointerData(this, state.size, state.type, state.stride, 423 (unsigned char *)state.data + firstIndex, datalen); 424 break; 425 case GLClientState::NORMAL_LOCATION: 426 this->glNormalPointerData(this, state.type, state.stride, 427 (unsigned char *)state.data + firstIndex, datalen); 428 break; 429 case GLClientState::COLOR_LOCATION: 430 this->glColorPointerData(this, state.size, state.type, state.stride, 431 (unsigned char *)state.data + firstIndex, datalen); 432 break; 433 case GLClientState::TEXCOORD0_LOCATION: 434 case GLClientState::TEXCOORD1_LOCATION: 435 case GLClientState::TEXCOORD2_LOCATION: 436 case GLClientState::TEXCOORD3_LOCATION: 437 case GLClientState::TEXCOORD4_LOCATION: 438 case GLClientState::TEXCOORD5_LOCATION: 439 case GLClientState::TEXCOORD6_LOCATION: 440 case GLClientState::TEXCOORD7_LOCATION: 441 m_state->setActiveTextureUnit(i - GLClientState::TEXCOORD0_LOCATION + GL_TEXTURE0); 442 if (m_state->getPriorityEnabledTarget(GL_INVALID_ENUM) != GL_INVALID_ENUM) { 443 this->glTexCoordPointerData(this, i - GLClientState::TEXCOORD0_LOCATION, state.size, state.type, state.stride, 444 (unsigned char *)state.data + firstIndex, datalen); 445 } 446 break; 447 case GLClientState::POINTSIZE_LOCATION: 448 this->glPointSizePointerData(this, state.type, state.stride, 449 (unsigned char *) state.data + firstIndex, datalen); 450 break; 451 case GLClientState::WEIGHT_LOCATION: 452 this->glWeightPointerData(this, state.size, state.type, state.stride, 453 (unsigned char * ) state.data + firstIndex, datalen); 454 break; 455 case GLClientState::MATRIXINDEX_LOCATION: 456 this->glMatrixIndexPointerData(this, state.size, state.type, state.stride, 457 (unsigned char *)state.data + firstIndex, datalen); 458 break; 459 } 460 } else { 461 462 switch(i) { 463 case GLClientState::VERTEX_LOCATION: 464 this->glVertexPointerOffset(this, state.size, state.type, state.stride, 465 (uintptr_t)state.data + firstIndex); 466 break; 467 case GLClientState::NORMAL_LOCATION: 468 this->glNormalPointerOffset(this, state.type, state.stride, 469 (uintptr_t)state.data + firstIndex); 470 break; 471 case GLClientState::POINTSIZE_LOCATION: 472 this->glPointSizePointerOffset(this, state.type, state.stride, 473 (uintptr_t)state.data + firstIndex); 474 break; 475 case GLClientState::COLOR_LOCATION: 476 this->glColorPointerOffset(this, state.size, state.type, state.stride, 477 (uintptr_t)state.data + firstIndex); 478 break; 479 case GLClientState::TEXCOORD0_LOCATION: 480 case GLClientState::TEXCOORD1_LOCATION: 481 case GLClientState::TEXCOORD2_LOCATION: 482 case GLClientState::TEXCOORD3_LOCATION: 483 case GLClientState::TEXCOORD4_LOCATION: 484 case GLClientState::TEXCOORD5_LOCATION: 485 case GLClientState::TEXCOORD6_LOCATION: 486 case GLClientState::TEXCOORD7_LOCATION: 487 this->glTexCoordPointerOffset(this, state.size, state.type, state.stride, 488 (uintptr_t)state.data + firstIndex); 489 break; 490 case GLClientState::WEIGHT_LOCATION: 491 this->glWeightPointerOffset(this,state.size,state.type,state.stride, 492 (uintptr_t)state.data+firstIndex); 493 break; 494 case GLClientState::MATRIXINDEX_LOCATION: 495 this->glMatrixIndexPointerOffset(this,state.size,state.type,state.stride, 496 (uintptr_t)state.data+firstIndex); 497 break; 498 } 499 } 500 this->m_glBindBuffer_enc(this, GL_ARRAY_BUFFER, m_state->currentArrayVbo()); 501 } else { 502 this->m_glDisableClientState_enc(this, state.glConst); 503 } 504 } 505 m_state->setActiveTextureUnit(prevActiveTexUnit); 506 } 507 508 void GLEncoder::s_glDrawArrays(void *self, GLenum mode, GLint first, GLsizei count) 509 { 510 GLEncoder *ctx = (GLEncoder *)self; 511 512 bool has_arrays = false; 513 for (int i = 0; i < GLClientState::LAST_LOCATION; i++) { 514 const GLClientState::VertexAttribState& state = ctx->m_state->getState(i); 515 if (state.enabled) { 516 if (state.bufferObject || state.data) { 517 has_arrays = true; 518 } else { 519 ALOGE("glDrawArrays: a vertex attribute array is enabled with no data bound\n"); 520 ctx->setError(GL_INVALID_OPERATION); 521 return; 522 } 523 } 524 } 525 if (!has_arrays) { 526 ALOGE("glDrawArrays: no data bound to the command - ignoring\n"); 527 return; 528 } 529 530 ctx->sendVertexData(first, count); 531 ctx->m_glDrawArrays_enc(ctx, mode, /*first*/ 0, count); 532 ctx->m_stream->flush(); 533 } 534 535 void GLEncoder::s_glDrawElements(void *self, GLenum mode, GLsizei count, GLenum type, const void *indices) 536 { 537 538 GLEncoder *ctx = (GLEncoder *)self; 539 assert(ctx->m_state != NULL); 540 SET_ERROR_IF(count<0, GL_INVALID_VALUE); 541 542 bool has_immediate_arrays = false; 543 bool has_indirect_arrays = false; 544 545 for (int i = 0; i < GLClientState::LAST_LOCATION; i++) { 546 const GLClientState::VertexAttribState& state = ctx->m_state->getState(i); 547 if (state.enabled) { 548 if (state.bufferObject != 0) { 549 has_indirect_arrays = true; 550 } else if (state.data) { 551 has_immediate_arrays = true; 552 } else { 553 ALOGE("glDrawElements: a vertex attribute array is enabled with no data bound\n"); 554 ctx->setError(GL_INVALID_OPERATION); 555 return; 556 } 557 } 558 } 559 560 if (!has_immediate_arrays && !has_indirect_arrays) { 561 ALOGE("glDrawElements: no data bound to the command - ignoring\n"); 562 return; 563 } 564 565 bool adjustIndices = true; 566 if (ctx->m_state->currentIndexVbo() != 0) { 567 if (!has_immediate_arrays) { 568 ctx->sendVertexData(0, count); 569 ctx->m_glBindBuffer_enc(self, GL_ELEMENT_ARRAY_BUFFER, ctx->m_state->currentIndexVbo()); 570 ctx->glDrawElementsOffset(ctx, mode, count, type, (uintptr_t)indices); 571 ctx->m_stream->flush(); 572 adjustIndices = false; 573 } else { 574 BufferData * buf = ctx->m_shared->getBufferData(ctx->m_state->currentIndexVbo()); 575 ctx->m_glBindBuffer_enc(self, GL_ELEMENT_ARRAY_BUFFER, 0); 576 indices = (void*)((GLintptr)buf->m_fixedBuffer.ptr() + (GLintptr)indices); 577 } 578 } 579 if (adjustIndices) { 580 void *adjustedIndices = (void*)indices; 581 int minIndex = 0, maxIndex = 0; 582 583 switch(type) { 584 case GL_BYTE: 585 case GL_UNSIGNED_BYTE: 586 GLUtils::minmax<unsigned char>((unsigned char *)indices, count, &minIndex, &maxIndex); 587 if (minIndex != 0) { 588 adjustedIndices = ctx->m_fixedBuffer.alloc(glSizeof(type) * count); 589 GLUtils::shiftIndices<unsigned char>((unsigned char *)indices, 590 (unsigned char *)adjustedIndices, 591 count, -minIndex); 592 } 593 break; 594 case GL_SHORT: 595 case GL_UNSIGNED_SHORT: 596 GLUtils::minmax<unsigned short>((unsigned short *)indices, count, &minIndex, &maxIndex); 597 if (minIndex != 0) { 598 adjustedIndices = ctx->m_fixedBuffer.alloc(glSizeof(type) * count); 599 GLUtils::shiftIndices<unsigned short>((unsigned short *)indices, 600 (unsigned short *)adjustedIndices, 601 count, -minIndex); 602 } 603 break; 604 case GL_INT: 605 case GL_UNSIGNED_INT: 606 GLUtils::minmax<unsigned int>((unsigned int *)indices, count, &minIndex, &maxIndex); 607 if (minIndex != 0) { 608 adjustedIndices = ctx->m_fixedBuffer.alloc(glSizeof(type) * count); 609 GLUtils::shiftIndices<unsigned int>((unsigned int *)indices, 610 (unsigned int *)adjustedIndices, 611 count, -minIndex); 612 } 613 break; 614 default: 615 ALOGE("unsupported index buffer type %d\n", type); 616 } 617 if (has_indirect_arrays || 1) { 618 ctx->sendVertexData(minIndex, maxIndex - minIndex + 1); 619 ctx->glDrawElementsData(ctx, mode, count, type, adjustedIndices, 620 count * glSizeof(type)); 621 ctx->m_stream->flush(); 622 // XXX - OPTIMIZATION (see the other else branch) should be implemented 623 if(!has_indirect_arrays) { 624 //ALOGD("unoptimized drawelements !!!\n"); 625 } 626 } else { 627 // we are all direct arrays and immidate mode index array - 628 // rebuild the arrays and the index array; 629 ALOGE("glDrawElements: direct index & direct buffer data - will be implemented in later versions;\n"); 630 } 631 } 632 } 633 634 void GLEncoder::s_glActiveTexture(void* self, GLenum texture) 635 { 636 GLEncoder* ctx = (GLEncoder*)self; 637 GLClientState* state = ctx->m_state; 638 GLenum err; 639 640 if ((err = state->setActiveTextureUnit(texture)) != GL_NO_ERROR) { 641 ALOGE("%s:%s:%d GL error %#x\n", __FILE__, __FUNCTION__, __LINE__, err); 642 ctx->setError(err); 643 return; 644 } 645 646 ctx->m_glActiveTexture_enc(ctx, texture); 647 } 648 649 void GLEncoder::s_glBindTexture(void* self, GLenum target, GLuint texture) 650 { 651 GLEncoder* ctx = (GLEncoder*)self; 652 GLClientState* state = ctx->m_state; 653 GLenum err; 654 655 GLboolean firstUse; 656 if ((err = state->bindTexture(target, texture, &firstUse)) != GL_NO_ERROR) { 657 ALOGE("%s:%s:%d GL error %#x\n", __FILE__, __FUNCTION__, __LINE__, err); 658 ctx->setError(err); 659 return; 660 } 661 662 if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES) { 663 ctx->m_glBindTexture_enc(ctx, target, texture); 664 return; 665 } 666 667 GLenum priorityTarget = state->getPriorityEnabledTarget(GL_TEXTURE_2D); 668 669 if (target == GL_TEXTURE_EXTERNAL_OES && firstUse) { 670 // set TEXTURE_EXTERNAL_OES default states which differ from TEXTURE_2D 671 ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D, texture); 672 ctx->m_glTexParameteri_enc(ctx, GL_TEXTURE_2D, 673 GL_TEXTURE_MIN_FILTER, GL_LINEAR); 674 ctx->m_glTexParameteri_enc(ctx, GL_TEXTURE_2D, 675 GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 676 ctx->m_glTexParameteri_enc(ctx, GL_TEXTURE_2D, 677 GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 678 679 if (target != priorityTarget) { 680 ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D, 681 state->getBoundTexture(GL_TEXTURE_2D)); 682 } 683 } 684 685 if (target == priorityTarget) { 686 ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D, texture); 687 } 688 } 689 690 void GLEncoder::s_glDeleteTextures(void* self, GLsizei n, const GLuint* textures) 691 { 692 GLEncoder* ctx = (GLEncoder*)self; 693 GLClientState* state = ctx->m_state; 694 695 state->deleteTextures(n, textures); 696 ctx->m_glDeleteTextures_enc(ctx, n, textures); 697 } 698 699 void GLEncoder::s_glDisable(void* self, GLenum cap) 700 { 701 GLEncoder* ctx = (GLEncoder*)self; 702 GLClientState* state = ctx->m_state; 703 704 if (cap == GL_TEXTURE_2D || cap == GL_TEXTURE_EXTERNAL_OES) { 705 GLenum prevTarget = state->getPriorityEnabledTarget(GL_INVALID_ENUM); 706 state->disableTextureTarget(cap); 707 GLenum currTarget = state->getPriorityEnabledTarget(GL_INVALID_ENUM); 708 709 if (prevTarget != currTarget) { 710 if (currTarget == GL_INVALID_ENUM) { 711 ctx->m_glDisable_enc(ctx, GL_TEXTURE_2D); 712 currTarget = GL_TEXTURE_2D; 713 } 714 // maintain the invariant that when TEXTURE_EXTERNAL_OES is 715 // disabled, the TEXTURE_2D binding is active, even if 716 // TEXTURE_2D is also disabled. 717 ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D, 718 state->getBoundTexture(currTarget)); 719 } 720 721 } else { 722 ctx->m_glDisable_enc(ctx, cap); 723 } 724 } 725 726 void GLEncoder::s_glEnable(void* self, GLenum cap) 727 { 728 GLEncoder* ctx = (GLEncoder*)self; 729 GLClientState* state = ctx->m_state; 730 731 if (cap == GL_TEXTURE_2D || cap == GL_TEXTURE_EXTERNAL_OES) { 732 GLenum prevTarget = state->getPriorityEnabledTarget(GL_INVALID_ENUM); 733 state->enableTextureTarget(cap); 734 GLenum currTarget = state->getPriorityEnabledTarget(GL_INVALID_ENUM); 735 736 if (prevTarget != currTarget) { 737 if (prevTarget == GL_INVALID_ENUM) { 738 ctx->m_glEnable_enc(ctx, GL_TEXTURE_2D); 739 } 740 if (currTarget == GL_TEXTURE_EXTERNAL_OES) { 741 ctx->m_glBindTexture_enc(ctx, GL_TEXTURE_2D, 742 state->getBoundTexture(currTarget)); 743 } 744 } 745 746 } else { 747 ctx->m_glEnable_enc(ctx, cap); 748 } 749 } 750 751 void GLEncoder::s_glGetTexParameterfv(void* self, 752 GLenum target, GLenum pname, GLfloat* params) 753 { 754 GLEncoder* ctx = (GLEncoder*)self; 755 const GLClientState* state = ctx->m_state; 756 757 if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { 758 ctx->override2DTextureTarget(target); 759 ctx->m_glGetTexParameterfv_enc(ctx, GL_TEXTURE_2D, pname, params); 760 ctx->restore2DTextureTarget(); 761 } else { 762 ctx->m_glGetTexParameterfv_enc(ctx, target, pname, params); 763 } 764 } 765 766 void GLEncoder::s_glGetTexParameteriv(void* self, 767 GLenum target, GLenum pname, GLint* params) 768 { 769 GLEncoder* ctx = (GLEncoder*)self; 770 const GLClientState* state = ctx->m_state; 771 772 switch (pname) { 773 case GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES: 774 *params = 1; 775 break; 776 777 default: 778 if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { 779 ctx->override2DTextureTarget(target); 780 ctx->m_glGetTexParameteriv_enc(ctx, GL_TEXTURE_2D, pname, params); 781 ctx->restore2DTextureTarget(); 782 } else { 783 ctx->m_glGetTexParameteriv_enc(ctx, target, pname, params); 784 } 785 break; 786 } 787 } 788 789 void GLEncoder::s_glGetTexParameterxv(void* self, 790 GLenum target, GLenum pname, GLfixed* params) 791 { 792 GLEncoder* ctx = (GLEncoder*)self; 793 const GLClientState* state = ctx->m_state; 794 795 if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { 796 ctx->override2DTextureTarget(target); 797 ctx->m_glGetTexParameterxv_enc(ctx, GL_TEXTURE_2D, pname, params); 798 ctx->restore2DTextureTarget(); 799 } else { 800 ctx->m_glGetTexParameterxv_enc(ctx, target, pname, params); 801 } 802 } 803 804 static bool isValidTextureExternalParam(GLenum pname, GLenum param) 805 { 806 switch (pname) { 807 case GL_TEXTURE_MIN_FILTER: 808 case GL_TEXTURE_MAG_FILTER: 809 return param == GL_NEAREST || param == GL_LINEAR; 810 811 case GL_TEXTURE_WRAP_S: 812 case GL_TEXTURE_WRAP_T: 813 return param == GL_CLAMP_TO_EDGE; 814 815 case GL_GENERATE_MIPMAP: 816 return param == GL_FALSE; 817 818 default: 819 return true; 820 } 821 } 822 823 void GLEncoder::s_glTexParameterf(void* self, 824 GLenum target, GLenum pname, GLfloat param) 825 { 826 GLEncoder* ctx = (GLEncoder*)self; 827 const GLClientState* state = ctx->m_state; 828 829 SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES && 830 !isValidTextureExternalParam(pname, (GLenum)param)), 831 GL_INVALID_ENUM); 832 833 if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { 834 ctx->override2DTextureTarget(target); 835 ctx->m_glTexParameterf_enc(ctx, GL_TEXTURE_2D, pname, param); 836 ctx->restore2DTextureTarget(); 837 } else { 838 ctx->m_glTexParameterf_enc(ctx, target, pname, param); 839 } 840 } 841 842 void GLEncoder::s_glTexParameterfv(void* self, 843 GLenum target, GLenum pname, const GLfloat* params) 844 { 845 GLEncoder* ctx = (GLEncoder*)self; 846 const GLClientState* state = ctx->m_state; 847 848 SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES && 849 !isValidTextureExternalParam(pname, (GLenum)params[0])), 850 GL_INVALID_ENUM); 851 852 if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { 853 ctx->override2DTextureTarget(target); 854 ctx->m_glTexParameterfv_enc(ctx, GL_TEXTURE_2D, pname, params); 855 ctx->restore2DTextureTarget(); 856 } else { 857 ctx->m_glTexParameterfv_enc(ctx, target, pname, params); 858 } 859 } 860 861 void GLEncoder::s_glTexParameteri(void* self, 862 GLenum target, GLenum pname, GLint param) 863 { 864 GLEncoder* ctx = (GLEncoder*)self; 865 const GLClientState* state = ctx->m_state; 866 867 SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES && 868 !isValidTextureExternalParam(pname, (GLenum)param)), 869 GL_INVALID_ENUM); 870 871 if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { 872 ctx->override2DTextureTarget(target); 873 ctx->m_glTexParameteri_enc(ctx, GL_TEXTURE_2D, pname, param); 874 ctx->restore2DTextureTarget(); 875 } else { 876 ctx->m_glTexParameteri_enc(ctx, target, pname, param); 877 } 878 } 879 880 void GLEncoder::s_glTexParameterx(void* self, 881 GLenum target, GLenum pname, GLfixed param) 882 { 883 GLEncoder* ctx = (GLEncoder*)self; 884 const GLClientState* state = ctx->m_state; 885 886 SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES && 887 !isValidTextureExternalParam(pname, (GLenum)param)), 888 GL_INVALID_ENUM); 889 890 if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { 891 ctx->override2DTextureTarget(target); 892 ctx->m_glTexParameterx_enc(ctx, GL_TEXTURE_2D, pname, param); 893 ctx->restore2DTextureTarget(); 894 } else { 895 ctx->m_glTexParameterx_enc(ctx, target, pname, param); 896 } 897 } 898 899 void GLEncoder::s_glTexParameteriv(void* self, 900 GLenum target, GLenum pname, const GLint* params) 901 { 902 GLEncoder* ctx = (GLEncoder*)self; 903 const GLClientState* state = ctx->m_state; 904 905 SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES && 906 !isValidTextureExternalParam(pname, (GLenum)params[0])), 907 GL_INVALID_ENUM); 908 909 if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { 910 ctx->override2DTextureTarget(target); 911 ctx->m_glTexParameteriv_enc(ctx, GL_TEXTURE_2D, pname, params); 912 ctx->restore2DTextureTarget(); 913 } else { 914 ctx->m_glTexParameteriv_enc(ctx, target, pname, params); 915 } 916 } 917 918 void GLEncoder::s_glTexParameterxv(void* self, 919 GLenum target, GLenum pname, const GLfixed* params) 920 { 921 GLEncoder* ctx = (GLEncoder*)self; 922 const GLClientState* state = ctx->m_state; 923 924 SET_ERROR_IF((target == GL_TEXTURE_EXTERNAL_OES && 925 !isValidTextureExternalParam(pname, (GLenum)params[0])), 926 GL_INVALID_ENUM); 927 928 if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) { 929 ctx->override2DTextureTarget(target); 930 ctx->m_glTexParameterxv_enc(ctx, GL_TEXTURE_2D, pname, params); 931 ctx->restore2DTextureTarget(); 932 } else { 933 ctx->m_glTexParameterxv_enc(ctx, target, pname, params); 934 } 935 } 936 937 void GLEncoder::override2DTextureTarget(GLenum target) 938 { 939 if ((target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) && 940 target != m_state->getPriorityEnabledTarget(GL_TEXTURE_2D)) { 941 m_glBindTexture_enc(this, GL_TEXTURE_2D, 942 m_state->getBoundTexture(target)); 943 } 944 } 945 946 void GLEncoder::restore2DTextureTarget() 947 { 948 GLenum priorityTarget = m_state->getPriorityEnabledTarget(GL_TEXTURE_2D); 949 m_glBindTexture_enc(this, GL_TEXTURE_2D, 950 m_state->getBoundTexture(priorityTarget)); 951 } 952 953 void GLEncoder::s_glGenFramebuffersOES(void* self, 954 GLsizei n, GLuint* framebuffers) { 955 GLEncoder* ctx = (GLEncoder*)self; 956 GLClientState* state = ctx->m_state; 957 958 SET_ERROR_IF(n < 0, GL_INVALID_VALUE); 959 960 ctx->m_glGenFramebuffersOES_enc(self, n, framebuffers); 961 state->addFramebuffers(n, framebuffers); 962 } 963 964 void GLEncoder::s_glDeleteFramebuffersOES(void* self, 965 GLsizei n, const GLuint* framebuffers) { 966 GLEncoder* ctx = (GLEncoder*)self; 967 GLClientState* state = ctx->m_state; 968 969 SET_ERROR_IF(n < 0, GL_INVALID_VALUE); 970 971 ctx->m_glDeleteFramebuffersOES_enc(self, n, framebuffers); 972 state->removeFramebuffers(n, framebuffers); 973 } 974 975 void GLEncoder::s_glBindFramebufferOES(void* self, 976 GLenum target, GLuint framebuffer) { 977 GLEncoder* ctx = (GLEncoder*)self; 978 GLClientState* state = ctx->m_state; 979 980 SET_ERROR_IF((target != GL_FRAMEBUFFER), 981 GL_INVALID_ENUM); 982 983 state->bindFramebuffer(target, framebuffer); 984 985 ctx->m_glBindFramebufferOES_enc(self, target, framebuffer); 986 } 987 988 void GLEncoder::s_glFramebufferTexture2DOES(void*self, 989 GLenum target, GLenum attachment, 990 GLenum textarget, GLuint texture, GLint level) { 991 GLEncoder* ctx = (GLEncoder*)self; 992 GLClientState* state = ctx->m_state; 993 994 state->attachTextureObject(target, attachment, texture); 995 996 ctx->m_glFramebufferTexture2DOES_enc(self, target, attachment, textarget, texture, level); 997 } 998 999 void GLEncoder::s_glFramebufferTexture2DMultisampleIMG(void* self, 1000 GLenum target, GLenum attachment, 1001 GLenum textarget, GLuint texture, GLint level, GLsizei samples) { 1002 GLEncoder* ctx = (GLEncoder*)self; 1003 GLClientState* state = ctx->m_state; 1004 1005 state->attachTextureObject(target, attachment, texture); 1006 1007 ctx->m_glFramebufferTexture2DMultisampleIMG_enc(self, target, attachment, textarget, texture, level, samples); 1008 } 1009 1010 void GLEncoder::s_glGetFramebufferAttachmentParameterivOES(void* self, 1011 GLenum target, GLenum attachment, GLenum pname, GLint* params) 1012 { 1013 GLEncoder* ctx = (GLEncoder*)self; 1014 const GLClientState* state = ctx->m_state; 1015 1016 SET_ERROR_IF(state->boundFramebuffer(GL_FRAMEBUFFER) == 0, 1017 GL_INVALID_OPERATION); 1018 SET_ERROR_IF((pname != GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE) && 1019 (!state->attachmentHasObject(GL_FRAMEBUFFER, attachment)), 1020 GL_INVALID_ENUM); 1021 1022 ctx->m_glGetFramebufferAttachmentParameterivOES_enc(self, target, attachment, pname, params); 1023 } 1024 1025 GLEncoder::GLEncoder(IOStream *stream, ChecksumCalculator *protocol) 1026 : gl_encoder_context_t(stream, protocol) 1027 { 1028 m_initialized = false; 1029 m_state = NULL; 1030 m_error = GL_NO_ERROR; 1031 m_num_compressedTextureFormats = 0; 1032 m_compressedTextureFormats = NULL; 1033 1034 // overrides; 1035 #define OVERRIDE(name) m_##name##_enc = this-> name ; this-> name = &s_##name 1036 1037 OVERRIDE(glFlush); 1038 OVERRIDE(glPixelStorei); 1039 OVERRIDE(glVertexPointer); 1040 OVERRIDE(glNormalPointer); 1041 OVERRIDE(glColorPointer); 1042 OVERRIDE(glPointSizePointerOES); 1043 OVERRIDE(glClientActiveTexture); 1044 OVERRIDE(glTexCoordPointer); 1045 OVERRIDE(glMatrixIndexPointerOES); 1046 OVERRIDE(glWeightPointerOES); 1047 1048 OVERRIDE(glGetIntegerv); 1049 OVERRIDE(glGetFloatv); 1050 OVERRIDE(glGetBooleanv); 1051 OVERRIDE(glGetFixedv); 1052 OVERRIDE(glGetPointerv); 1053 1054 OVERRIDE(glBindBuffer); 1055 OVERRIDE(glBufferData); 1056 OVERRIDE(glBufferSubData); 1057 OVERRIDE(glDeleteBuffers); 1058 1059 OVERRIDE(glEnableClientState); 1060 OVERRIDE(glDisableClientState); 1061 OVERRIDE(glIsEnabled); 1062 OVERRIDE(glDrawArrays); 1063 OVERRIDE(glDrawElements); 1064 1065 this->glGetString = s_glGetString; 1066 this->glFinish = s_glFinish; 1067 1068 OVERRIDE(glGetError); 1069 1070 OVERRIDE(glActiveTexture); 1071 OVERRIDE(glBindTexture); 1072 OVERRIDE(glDeleteTextures); 1073 OVERRIDE(glDisable); 1074 OVERRIDE(glEnable); 1075 OVERRIDE(glGetTexParameterfv); 1076 OVERRIDE(glGetTexParameteriv); 1077 OVERRIDE(glGetTexParameterxv); 1078 OVERRIDE(glTexParameterf); 1079 OVERRIDE(glTexParameterfv); 1080 OVERRIDE(glTexParameteri); 1081 OVERRIDE(glTexParameterx); 1082 OVERRIDE(glTexParameteriv); 1083 OVERRIDE(glTexParameterxv); 1084 1085 OVERRIDE(glGenFramebuffersOES); 1086 OVERRIDE(glDeleteFramebuffersOES); 1087 OVERRIDE(glBindFramebufferOES); 1088 OVERRIDE(glFramebufferTexture2DOES); 1089 OVERRIDE(glFramebufferTexture2DMultisampleIMG); 1090 OVERRIDE(glGetFramebufferAttachmentParameterivOES); 1091 } 1092 1093 GLEncoder::~GLEncoder() 1094 { 1095 delete [] m_compressedTextureFormats; 1096 } 1097 1098 size_t GLEncoder::pixelDataSize(GLsizei width, GLsizei height, GLenum format, GLenum type, int pack) 1099 { 1100 assert(m_state != NULL); 1101 return m_state->pixelDataSize(width, height, 1, format, type, pack); 1102 } 1103 1104 void GLEncoder::s_glFinish(void *self) 1105 { 1106 GLEncoder *ctx = (GLEncoder *)self; 1107 ctx->glFinishRoundTrip(self); 1108 } 1109
