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
s_glGetError(void * self)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
getCompressedTextureFormats()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
s_glGetIntegerv(void * self,GLenum param,GLint * ptr)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
s_glGetFloatv(void * self,GLenum param,GLfloat * ptr)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
s_glGetFixedv(void * self,GLenum param,GLfixed * ptr)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
s_glGetBooleanv(void * self,GLenum param,GLboolean * ptr)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
s_glGetPointerv(void * self,GLenum param,GLvoid ** params)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
s_glFlush(void * self)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
s_glGetString(void * self,GLenum name)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
s_glPixelStorei(void * self,GLenum param,GLint value)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
s_glVertexPointer(void * self,int size,GLenum type,GLsizei stride,const void * data)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
s_glNormalPointer(void * self,GLenum type,GLsizei stride,const void * data)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
s_glColorPointer(void * self,int size,GLenum type,GLsizei stride,const void * data)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
s_glPointSizePointerOES(void * self,GLenum type,GLsizei stride,const void * data)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
s_glClientActiveTexture(void * self,GLenum texture)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
s_glTexCoordPointer(void * self,int size,GLenum type,GLsizei stride,const void * data)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
s_glMatrixIndexPointerOES(void * self,int size,GLenum type,GLsizei stride,const void * data)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
s_glWeightPointerOES(void * self,int size,GLenum type,GLsizei stride,const void * data)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
s_glEnableClientState(void * self,GLenum state)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
s_glDisableClientState(void * self,GLenum state)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
s_glIsEnabled(void * self,GLenum cap)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
s_glBindBuffer(void * self,GLenum target,GLuint id)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
s_glBufferData(void * self,GLenum target,GLsizeiptr size,const GLvoid * data,GLenum usage)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
s_glBufferSubData(void * self,GLenum target,GLintptr offset,GLsizeiptr size,const GLvoid * data)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
s_glDeleteBuffers(void * self,GLsizei n,const GLuint * buffers)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
sendVertexData(unsigned int first,unsigned int count)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
s_glDrawArrays(void * self,GLenum mode,GLint first,GLsizei count)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
s_glDrawElements(void * self,GLenum mode,GLsizei count,GLenum type,const void * indices)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
s_glActiveTexture(void * self,GLenum texture)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
s_glBindTexture(void * self,GLenum target,GLuint texture)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
s_glDeleteTextures(void * self,GLsizei n,const GLuint * textures)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
s_glDisable(void * self,GLenum cap)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
s_glEnable(void * self,GLenum cap)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
s_glGetTexParameterfv(void * self,GLenum target,GLenum pname,GLfloat * params)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
s_glGetTexParameteriv(void * self,GLenum target,GLenum pname,GLint * params)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
s_glGetTexParameterxv(void * self,GLenum target,GLenum pname,GLfixed * params)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
isValidTextureExternalParam(GLenum pname,GLenum param)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
s_glTexParameterf(void * self,GLenum target,GLenum pname,GLfloat param)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
s_glTexParameterfv(void * self,GLenum target,GLenum pname,const GLfloat * params)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
s_glTexParameteri(void * self,GLenum target,GLenum pname,GLint param)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
s_glTexParameterx(void * self,GLenum target,GLenum pname,GLfixed param)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
s_glTexParameteriv(void * self,GLenum target,GLenum pname,const GLint * params)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
s_glTexParameterxv(void * self,GLenum target,GLenum pname,const GLfixed * params)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
override2DTextureTarget(GLenum target)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
restore2DTextureTarget()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
s_glGenFramebuffersOES(void * self,GLsizei n,GLuint * framebuffers)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
s_glDeleteFramebuffersOES(void * self,GLsizei n,const GLuint * framebuffers)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
s_glBindFramebufferOES(void * self,GLenum target,GLuint framebuffer)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
s_glFramebufferTexture2DOES(void * self,GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)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
s_glFramebufferTexture2DMultisampleIMG(void * self,GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLsizei samples)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
s_glGetFramebufferAttachmentParameterivOES(void * self,GLenum target,GLenum attachment,GLenum pname,GLint * params)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
GLEncoder(IOStream * stream,ChecksumCalculator * protocol)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
~GLEncoder()1093 GLEncoder::~GLEncoder()
1094 {
1095 delete [] m_compressedTextureFormats;
1096 }
1097
pixelDataSize(GLsizei width,GLsizei height,GLenum format,GLenum type,int pack)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
s_glFinish(void * self)1104 void GLEncoder::s_glFinish(void *self)
1105 {
1106 GLEncoder *ctx = (GLEncoder *)self;
1107 ctx->glFinishRoundTrip(self);
1108 }
1109