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->setState(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->setState(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->setState(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->setState(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->setState(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->setState(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->setState(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 
348     if (state!=NULL)
349       return state->enabled;
350 
351     return ctx->m_glIsEnabled_enc(self,cap);
352 }
353 
s_glBindBuffer(void * self,GLenum target,GLuint id)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 
s_glBufferData(void * self,GLenum target,GLsizeiptr size,const GLvoid * data,GLenum usage)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 
s_glBufferSubData(void * self,GLenum target,GLintptr offset,GLsizeiptr size,const GLvoid * data)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 
s_glDeleteBuffers(void * self,GLsizei n,const GLuint * buffers)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 
sendVertexData(unsigned int first,unsigned int count)396 void GLEncoder::sendVertexData(unsigned int first, unsigned int count)
397 {
398     assert(m_state != NULL);
399     for (int i = 0; i < GLClientState::LAST_LOCATION; i++) {
400         bool enableDirty;
401         const GLClientState::VertexAttribState *state = m_state->getStateAndEnableDirty(i, &enableDirty);
402 
403         // do not process if state not valid
404         if (!state) continue;
405 
406         // do not send disable state if state was already disabled
407         if (!enableDirty && !state->enabled) continue;
408 
409         if ( i >= GLClientState::TEXCOORD0_LOCATION &&
410             i <= GLClientState::TEXCOORD7_LOCATION ) {
411             m_glClientActiveTexture_enc(this, GL_TEXTURE0 + i - GLClientState::TEXCOORD0_LOCATION);
412         }
413 
414         if (state->enabled) {
415 
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                     this->glTexCoordPointerData(this, i - GLClientState::TEXCOORD0_LOCATION, state->size, state->type, state->stride,
449                                                 (unsigned char *)state->data + firstIndex, datalen);
450                     break;
451                 case GLClientState::POINTSIZE_LOCATION:
452                     this->glPointSizePointerData(this, state->type, state->stride,
453                                                  (unsigned char *) state->data + firstIndex, datalen);
454                     break;
455                 case GLClientState::WEIGHT_LOCATION:
456                     this->glWeightPointerData(this, state->size, state->type, state->stride,
457                                               (unsigned char * ) state->data + firstIndex, datalen);
458                     break;
459                 case GLClientState::MATRIXINDEX_LOCATION:
460                     this->glMatrixIndexPointerData(this, state->size, state->type, state->stride,
461                                                   (unsigned char *)state->data + firstIndex, datalen);
462                     break;
463                 }
464             } else {
465 
466                 switch(i) {
467                 case GLClientState::VERTEX_LOCATION:
468                     this->glVertexPointerOffset(this, state->size, state->type, state->stride,
469                                                 (uintptr_t)state->data + firstIndex);
470                     break;
471                 case GLClientState::NORMAL_LOCATION:
472                     this->glNormalPointerOffset(this, state->type, state->stride,
473                                                 (uintptr_t)state->data + firstIndex);
474                     break;
475                 case GLClientState::POINTSIZE_LOCATION:
476                     this->glPointSizePointerOffset(this, state->type, state->stride,
477                                                    (uintptr_t)state->data + firstIndex);
478                     break;
479                 case GLClientState::COLOR_LOCATION:
480                     this->glColorPointerOffset(this, state->size, state->type, state->stride,
481                                                (uintptr_t)state->data + firstIndex);
482                     break;
483                 case GLClientState::TEXCOORD0_LOCATION:
484                 case GLClientState::TEXCOORD1_LOCATION:
485                 case GLClientState::TEXCOORD2_LOCATION:
486                 case GLClientState::TEXCOORD3_LOCATION:
487                 case GLClientState::TEXCOORD4_LOCATION:
488                 case GLClientState::TEXCOORD5_LOCATION:
489                 case GLClientState::TEXCOORD6_LOCATION:
490                 case GLClientState::TEXCOORD7_LOCATION:
491                     this->glTexCoordPointerOffset(this, state->size, state->type, state->stride,
492                                                   (uintptr_t)state->data + firstIndex);
493                     break;
494                 case GLClientState::WEIGHT_LOCATION:
495                     this->glWeightPointerOffset(this,state->size,state->type,state->stride,
496                                                 (uintptr_t)state->data+firstIndex);
497                     break;
498                 case GLClientState::MATRIXINDEX_LOCATION:
499                     this->glMatrixIndexPointerOffset(this,state->size,state->type,state->stride,
500                                               (uintptr_t)state->data+firstIndex);
501                     break;
502                 }
503             }
504             this->m_glBindBuffer_enc(this, GL_ARRAY_BUFFER, m_state->currentArrayVbo());
505         } else {
506             this->m_glDisableClientState_enc(this, state->glConst);
507         }
508     }
509 }
510 
s_glDrawArrays(void * self,GLenum mode,GLint first,GLsizei count)511 void GLEncoder::s_glDrawArrays(void *self, GLenum mode, GLint first, GLsizei count)
512 {
513     GLEncoder *ctx = (GLEncoder *)self;
514 
515     bool has_arrays = false;
516     for (int i = 0; i < GLClientState::LAST_LOCATION; i++) {
517         const GLClientState::VertexAttribState *state = ctx->m_state->getState(i);
518         if (state->enabled) {
519             if (state->bufferObject || state->data) {
520                 has_arrays = true;
521             } else {
522                 ALOGE("glDrawArrays: a vertex attribute array is enabled with no data bound\n");
523                 ctx->setError(GL_INVALID_OPERATION);
524                 return;
525             }
526         }
527     }
528     if (!has_arrays) {
529         ALOGE("glDrawArrays: no data bound to the command - ignoring\n");
530         return;
531     }
532 
533     ctx->sendVertexData(first, count);
534     ctx->m_glDrawArrays_enc(ctx, mode, /*first*/ 0, count);
535 }
536 
s_glDrawElements(void * self,GLenum mode,GLsizei count,GLenum type,const void * indices)537 void GLEncoder::s_glDrawElements(void *self, GLenum mode, GLsizei count, GLenum type, const void *indices)
538 {
539 
540     GLEncoder *ctx = (GLEncoder *)self;
541     assert(ctx->m_state != NULL);
542     SET_ERROR_IF(count<0, GL_INVALID_VALUE);
543 
544     bool has_immediate_arrays = false;
545     bool has_indirect_arrays = false;
546 
547     for (int i = 0; i < GLClientState::LAST_LOCATION; i++) {
548         const GLClientState::VertexAttribState *state = ctx->m_state->getState(i);
549         if (state->enabled) {
550             if (state->bufferObject != 0) {
551                 has_indirect_arrays = true;
552             } else if (state->data) {
553                 has_immediate_arrays = true;
554             } else {
555                 ALOGE("glDrawElements: a vertex attribute array is enabled with no data bound\n");
556                 ctx->setError(GL_INVALID_OPERATION);
557                 return;
558             }
559         }
560     }
561 
562     if (!has_immediate_arrays && !has_indirect_arrays) {
563         ALOGE("glDrawElements: no data bound to the command - ignoring\n");
564         return;
565     }
566 
567     bool adjustIndices = true;
568     if (ctx->m_state->currentIndexVbo() != 0) {
569         if (!has_immediate_arrays) {
570             ctx->sendVertexData(0, count);
571             ctx->m_glBindBuffer_enc(self, GL_ELEMENT_ARRAY_BUFFER, ctx->m_state->currentIndexVbo());
572             ctx->glDrawElementsOffset(ctx, mode, count, type, (uintptr_t)indices);
573             adjustIndices = false;
574         } else {
575             BufferData * buf = ctx->m_shared->getBufferData(ctx->m_state->currentIndexVbo());
576             ctx->m_glBindBuffer_enc(self, GL_ELEMENT_ARRAY_BUFFER, 0);
577             indices = (void*)((GLintptr)buf->m_fixedBuffer.ptr() + (GLintptr)indices);
578         }
579     }
580     if (adjustIndices) {
581         void *adjustedIndices = (void*)indices;
582         int minIndex = 0, maxIndex = 0;
583 
584         switch(type) {
585         case GL_BYTE:
586         case GL_UNSIGNED_BYTE:
587             GLUtils::minmax<unsigned char>((unsigned char *)indices, count, &minIndex, &maxIndex);
588             if (minIndex != 0) {
589                 adjustedIndices =  ctx->m_fixedBuffer.alloc(glSizeof(type) * count);
590                 GLUtils::shiftIndices<unsigned char>((unsigned char *)indices,
591                                                  (unsigned char *)adjustedIndices,
592                                                  count, -minIndex);
593             }
594             break;
595         case GL_SHORT:
596         case GL_UNSIGNED_SHORT:
597             GLUtils::minmax<unsigned short>((unsigned short *)indices, count, &minIndex, &maxIndex);
598             if (minIndex != 0) {
599                 adjustedIndices = ctx->m_fixedBuffer.alloc(glSizeof(type) * count);
600                 GLUtils::shiftIndices<unsigned short>((unsigned short *)indices,
601                                                  (unsigned short *)adjustedIndices,
602                                                  count, -minIndex);
603             }
604             break;
605         case GL_INT:
606         case GL_UNSIGNED_INT:
607             GLUtils::minmax<unsigned int>((unsigned int *)indices, count, &minIndex, &maxIndex);
608             if (minIndex != 0) {
609                 adjustedIndices = ctx->m_fixedBuffer.alloc(glSizeof(type) * count);
610                 GLUtils::shiftIndices<unsigned int>((unsigned int *)indices,
611                                                  (unsigned int *)adjustedIndices,
612                                                  count, -minIndex);
613             }
614             break;
615         default:
616             ALOGE("unsupported index buffer type %d\n", type);
617         }
618         if (has_indirect_arrays || 1) {
619             ctx->sendVertexData(minIndex, maxIndex - minIndex + 1);
620             ctx->glDrawElementsData(ctx, mode, count, type, adjustedIndices,
621                                       count * glSizeof(type));
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 
GLEncoder(IOStream * stream,ChecksumCalculator * protocol)953 GLEncoder::GLEncoder(IOStream *stream, ChecksumCalculator *protocol)
954         : gl_encoder_context_t(stream, protocol)
955 {
956     m_initialized = false;
957     m_state = NULL;
958     m_error = GL_NO_ERROR;
959     m_num_compressedTextureFormats = 0;
960     m_compressedTextureFormats = NULL;
961 
962     // overrides;
963 #define OVERRIDE(name)  m_##name##_enc = this-> name ; this-> name = &s_##name
964 
965     OVERRIDE(glFlush);
966     OVERRIDE(glPixelStorei);
967     OVERRIDE(glVertexPointer);
968     OVERRIDE(glNormalPointer);
969     OVERRIDE(glColorPointer);
970     OVERRIDE(glPointSizePointerOES);
971     OVERRIDE(glClientActiveTexture);
972     OVERRIDE(glTexCoordPointer);
973     OVERRIDE(glMatrixIndexPointerOES);
974     OVERRIDE(glWeightPointerOES);
975 
976     OVERRIDE(glGetIntegerv);
977     OVERRIDE(glGetFloatv);
978     OVERRIDE(glGetBooleanv);
979     OVERRIDE(glGetFixedv);
980     OVERRIDE(glGetPointerv);
981 
982     OVERRIDE(glBindBuffer);
983     OVERRIDE(glBufferData);
984     OVERRIDE(glBufferSubData);
985     OVERRIDE(glDeleteBuffers);
986 
987     OVERRIDE(glEnableClientState);
988     OVERRIDE(glDisableClientState);
989     OVERRIDE(glIsEnabled);
990     OVERRIDE(glDrawArrays);
991     OVERRIDE(glDrawElements);
992 
993     this->glGetString = s_glGetString;
994     this->glFinish = s_glFinish;
995 
996     OVERRIDE(glGetError);
997 
998     OVERRIDE(glActiveTexture);
999     OVERRIDE(glBindTexture);
1000     OVERRIDE(glDeleteTextures);
1001     OVERRIDE(glDisable);
1002     OVERRIDE(glEnable);
1003     OVERRIDE(glGetTexParameterfv);
1004     OVERRIDE(glGetTexParameteriv);
1005     OVERRIDE(glGetTexParameterxv);
1006     OVERRIDE(glTexParameterf);
1007     OVERRIDE(glTexParameterfv);
1008     OVERRIDE(glTexParameteri);
1009     OVERRIDE(glTexParameterx);
1010     OVERRIDE(glTexParameteriv);
1011     OVERRIDE(glTexParameterxv);
1012 }
1013 
~GLEncoder()1014 GLEncoder::~GLEncoder()
1015 {
1016     delete [] m_compressedTextureFormats;
1017 }
1018 
pixelDataSize(GLsizei width,GLsizei height,GLenum format,GLenum type,int pack)1019 size_t GLEncoder::pixelDataSize(GLsizei width, GLsizei height, GLenum format, GLenum type, int pack)
1020 {
1021     assert(m_state != NULL);
1022     return m_state->pixelDataSize(width, height, format, type, pack);
1023 }
1024 
s_glFinish(void * self)1025 void GLEncoder::s_glFinish(void *self)
1026 {
1027     GLEncoder *ctx = (GLEncoder *)self;
1028     ctx->glFinishRoundTrip(self);
1029 }
1030