src/type3_AndroidCloud/anbox-master/android/opengl/shared/OpenglCodecCommon/GLClientState.cpp

   1 /*
   2 * Copyright (C) 2011 The Android Open Source Project
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16 #include "GLClientState.h"
  17 #include "ErrorLog.h"
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include "glUtils.h"
  22 #include <cutils/log.h>
  23
  24 #ifndef MAX
  25 #define MAX(a, b) ((a) < (b) ? (b) : (a))
  26 #endif
  27
  28 GLClientState::GLClientState(int nLocations)
  29 {
  30     if (nLocations < LAST_LOCATION) {
  31         nLocations = LAST_LOCATION;
  32     }
  33     m_nLocations = nLocations;
  34     m_states = new VertexAttribState[m_nLocations];
  35     for (int i = 0; i < m_nLocations; i++) {
  36         m_states[i].enabled = 0;
  37         m_states[i].enableDirty = false;
  38         m_states[i].data = 0;
  39     }
  40     m_currentArrayVbo = 0;
  41     m_currentIndexVbo = 0;
  42     // init gl constans;
  43     m_states[VERTEX_LOCATION].glConst = GL_VERTEX_ARRAY;
  44     m_states[NORMAL_LOCATION].glConst = GL_NORMAL_ARRAY;
  45     m_states[COLOR_LOCATION].glConst = GL_COLOR_ARRAY;
  46     m_states[POINTSIZE_LOCATION].glConst = GL_POINT_SIZE_ARRAY_OES;
  47     m_states[TEXCOORD0_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
  48     m_states[TEXCOORD1_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
  49     m_states[TEXCOORD2_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
  50     m_states[TEXCOORD3_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
  51     m_states[TEXCOORD4_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
  52     m_states[TEXCOORD5_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
  53     m_states[TEXCOORD6_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
  54     m_states[TEXCOORD7_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
  55     m_states[MATRIXINDEX_LOCATION].glConst = GL_MATRIX_INDEX_ARRAY_OES;
  56     m_states[WEIGHT_LOCATION].glConst = GL_WEIGHT_ARRAY_OES;
  57     m_activeTexture = 0;
  58     m_currentProgram = 0;
  59
  60     m_pixelStore.unpack_alignment = 4;
  61     m_pixelStore.pack_alignment = 4;
  62
  63     memset(m_tex.unit, 0, sizeof(m_tex.unit));
  64     m_tex.activeUnit = &m_tex.unit[0];
  65     m_tex.textures = NULL;
  66     m_tex.numTextures = 0;
  67     m_tex.allocTextures = 0;
  68
  69     m_maxVertexAttribsDirty = true;
  70 }
  71
  72 GLClientState::~GLClientState()
  73 {
  74     delete m_states;
  75 }
  76
  77 void GLClientState::enable(int location, int state)
  78 {
  79     if (!validLocation(location)) {
  80         return;
  81     }
  82
  83     m_states[location].enableDirty |= (state != m_states[location].enabled);
  84     m_states[location].enabled = state;
  85 }
  86
  87 void GLClientState::setState(int location, int size, GLenum type, GLboolean normalized, GLsizei stride, const void *data)
  88 {
  89     if (!validLocation(location)) {
  90         return;
  91     }
  92     m_states[location].size = size;
  93     m_states[location].type = type;
  94     m_states[location].stride = stride;
  95     m_states[location].data = (void*)data;
  96     m_states[location].bufferObject = m_currentArrayVbo;
  97     m_states[location].elementSize = size ? (glSizeof(type) * size) : 0;
  98     m_states[location].normalized = normalized;
  99 }
 100
 101 void GLClientState::setBufferObject(int location, GLuint id)
 102 {
 103     if (!validLocation(location)) {
 104         return;
 105     }
 106
 107     m_states[location].bufferObject = id;
 108 }
 109
 110 const GLClientState::VertexAttribState * GLClientState::getState(int location)
 111 {
 112     if (!validLocation(location)) {
 113         return NULL;
 114     }
 115     return & m_states[location];
 116 }
 117
 118 const GLClientState::VertexAttribState * GLClientState::getStateAndEnableDirty(int location, bool *enableChanged)
 119 {
 120     if (!validLocation(location)) {
 121         return NULL;
 122     }
 123
 124     if (enableChanged) {
 125         *enableChanged = m_states[location].enableDirty;
 126     }
 127
 128     m_states[location].enableDirty = false;
 129     return & m_states[location];
 130 }
 131
 132 int GLClientState::getLocation(GLenum loc)
 133 {
 134     int retval;
 135
 136     switch(loc) {
 137     case GL_VERTEX_ARRAY:
 138         retval = int(VERTEX_LOCATION);
 139         break;
 140     case GL_NORMAL_ARRAY:
 141         retval = int(NORMAL_LOCATION);
 142         break;
 143     case GL_COLOR_ARRAY:
 144         retval = int(COLOR_LOCATION);
 145         break;
 146     case GL_POINT_SIZE_ARRAY_OES:
 147         retval = int(POINTSIZE_LOCATION);
 148         break;
 149     case GL_TEXTURE_COORD_ARRAY:
 150         retval = int (TEXCOORD0_LOCATION + m_activeTexture);
 151         break;
 152     case GL_MATRIX_INDEX_ARRAY_OES:
 153         retval = int (MATRIXINDEX_LOCATION);
 154         break;
 155     case GL_WEIGHT_ARRAY_OES:
 156         retval = int (WEIGHT_LOCATION);
 157         break;
 158     default:
 159         retval = loc;
 160     }
 161     return retval;
 162 }
 163
 164 void GLClientState::getClientStatePointer(GLenum pname, GLvoid** params)
 165 {
 166     const GLClientState::VertexAttribState *state = NULL;
 167     switch (pname) {
 168     case GL_VERTEX_ARRAY_POINTER: {
 169         state = getState(GLClientState::VERTEX_LOCATION);
 170         break;
 171         }
 172     case GL_NORMAL_ARRAY_POINTER: {
 173         state = getState(GLClientState::NORMAL_LOCATION);
 174         break;
 175         }
 176     case GL_COLOR_ARRAY_POINTER: {
 177         state = getState(GLClientState::COLOR_LOCATION);
 178         break;
 179         }
 180     case GL_TEXTURE_COORD_ARRAY_POINTER: {
 181         state = getState(getActiveTexture() + GLClientState::TEXCOORD0_LOCATION);
 182         break;
 183         }
 184     case GL_POINT_SIZE_ARRAY_POINTER_OES: {
 185         state = getState(GLClientState::POINTSIZE_LOCATION);
 186         break;
 187         }
 188     case GL_MATRIX_INDEX_ARRAY_POINTER_OES: {
 189         state = getState(GLClientState::MATRIXINDEX_LOCATION);
 190         break;
 191         }
 192     case GL_WEIGHT_ARRAY_POINTER_OES: {
 193         state = getState(GLClientState::WEIGHT_LOCATION);
 194         break;
 195         }
 196     }
 197     if (state && params)
 198         *params = state->data;
 199 }
 200
 201 int GLClientState::setPixelStore(GLenum param, GLint value)
 202 {
 203     int retval = 0;
 204     switch(param) {
 205     case GL_UNPACK_ALIGNMENT:
 206         if (value == 1 || value == 2 || value == 4 || value == 8) {
 207             m_pixelStore.unpack_alignment = value;
 208         } else {
 209             retval =  GL_INVALID_VALUE;
 210         }
 211         break;
 212     case GL_PACK_ALIGNMENT:
 213         if (value == 1 || value == 2 || value == 4 || value == 8) {
 214             m_pixelStore.pack_alignment = value;
 215         } else {
 216             retval =  GL_INVALID_VALUE;
 217         }
 218         break;
 219         default:
 220             retval = GL_INVALID_ENUM;
 221     }
 222     return retval;
 223 }
 224
 225
 226
 227
 228 size_t GLClientState::pixelDataSize(GLsizei width, GLsizei height, GLenum format, GLenum type, int pack) const
 229 {
 230     if (width <= 0 || height <= 0) return 0;
 231
 232     int pixelsize = glUtilsPixelBitSize(format, type) >> 3;
 233
 234     int alignment = pack ? m_pixelStore.pack_alignment : m_pixelStore.unpack_alignment;
 235
 236     if (pixelsize == 0 ) {
 237         ERR("unknown pixel size: width: %d height: %d format: %d type: %d pack: %d align: %d\n",
 238              width, height, format, type, pack, alignment);
 239     }
 240     size_t linesize = pixelsize * width;
 241     size_t aligned_linesize = int(linesize / alignment) * alignment;
 242     if (aligned_linesize < linesize) {
 243         aligned_linesize += alignment;
 244     }
 245     return aligned_linesize * height;
 246 }
 247
 248 GLenum GLClientState::setActiveTextureUnit(GLenum texture)
 249 {
 250     GLuint unit = texture - GL_TEXTURE0;
 251     if (unit >= MAX_TEXTURE_UNITS) {
 252         return GL_INVALID_ENUM;
 253     }
 254     m_tex.activeUnit = &m_tex.unit[unit];
 255     return GL_NO_ERROR;
 256 }
 257
 258 GLenum GLClientState::getActiveTextureUnit() const
 259 {
 260     return GL_TEXTURE0 + (m_tex.activeUnit - &m_tex.unit[0]);
 261 }
 262
 263 void GLClientState::enableTextureTarget(GLenum target)
 264 {
 265     switch (target) {
 266     case GL_TEXTURE_2D:
 267         m_tex.activeUnit->enables |= (1u << TEXTURE_2D);
 268         break;
 269     case GL_TEXTURE_EXTERNAL_OES:
 270         m_tex.activeUnit->enables |= (1u << TEXTURE_EXTERNAL);
 271         break;
 272     }
 273 }
 274
 275 void GLClientState::disableTextureTarget(GLenum target)
 276 {
 277     switch (target) {
 278     case GL_TEXTURE_2D:
 279         m_tex.activeUnit->enables &= ~(1u << TEXTURE_2D);
 280         break;
 281     case GL_TEXTURE_EXTERNAL_OES:
 282         m_tex.activeUnit->enables &= ~(1u << TEXTURE_EXTERNAL);
 283         break;
 284     }
 285 }
 286
 287 GLenum GLClientState::getPriorityEnabledTarget(GLenum allDisabled) const
 288 {
 289     unsigned int enables = m_tex.activeUnit->enables;
 290     if (enables & (1u << TEXTURE_EXTERNAL)) {
 291         return GL_TEXTURE_EXTERNAL_OES;
 292     } else if (enables & (1u << TEXTURE_2D)) {
 293         return GL_TEXTURE_2D;
 294     } else {
 295         return allDisabled;
 296     }
 297 }
 298
 299 int GLClientState::compareTexId(const void* pid, const void* prec)
 300 {
 301     const GLuint* id = (const GLuint*)pid;
 302     const TextureRec* rec = (const TextureRec*)prec;
 303     return (GLint)(*id) - (GLint)rec->id;
 304 }
 305
 306 GLenum GLClientState::bindTexture(GLenum target, GLuint texture,
 307         GLboolean* firstUse)
 308 {
 309     GLboolean first = GL_FALSE;
 310     TextureRec* texrec = NULL;
 311     if (texture != 0) {
 312         if (m_tex.textures) {
 313             texrec = (TextureRec*)bsearch(&texture, m_tex.textures,
 314                     m_tex.numTextures, sizeof(TextureRec), compareTexId);
 315         }
 316         if (!texrec) {
 317             if (!(texrec = addTextureRec(texture, target))) {
 318                 return GL_OUT_OF_MEMORY;
 319             }
 320             first = GL_TRUE;
 321         }
 322         if (target != texrec->target) {
 323             return GL_INVALID_OPERATION;
 324         }
 325     }
 326
 327     switch (target) {
 328     case GL_TEXTURE_2D:
 329         m_tex.activeUnit->texture[TEXTURE_2D] = texture;
 330         break;
 331     case GL_TEXTURE_EXTERNAL_OES:
 332         m_tex.activeUnit->texture[TEXTURE_EXTERNAL] = texture;
 333         break;
 334     }
 335
 336     if (firstUse) {
 337         *firstUse = first;
 338     }
 339
 340     return GL_NO_ERROR;
 341 }
 342
 343 GLClientState::TextureRec* GLClientState::addTextureRec(GLuint id,
 344         GLenum target)
 345 {
 346     if (m_tex.numTextures == m_tex.allocTextures) {
 347         const GLuint MAX_TEXTURES = 0xFFFFFFFFu;
 348
 349         GLuint newAlloc;
 350         if (MAX_TEXTURES - m_tex.allocTextures >= m_tex.allocTextures) {
 351             newAlloc = MAX(4, 2 * m_tex.allocTextures);
 352         } else {
 353             if (m_tex.allocTextures == MAX_TEXTURES) {
 354                 return NULL;
 355             }
 356             newAlloc = MAX_TEXTURES;
 357         }
 358
 359         TextureRec* newTextures = (TextureRec*)realloc(m_tex.textures,
 360                 newAlloc * sizeof(TextureRec));
 361         if (!newTextures) {
 362             return NULL;
 363         }
 364
 365         m_tex.textures = newTextures;
 366         m_tex.allocTextures = newAlloc;
 367     }
 368
 369     TextureRec* tex = m_tex.textures + m_tex.numTextures;
 370     TextureRec* prev = tex - 1;
 371     while (tex != m_tex.textures && id < prev->id) {
 372         *tex-- = *prev--;
 373     }
 374     tex->id = id;
 375     tex->target = target;
 376     m_tex.numTextures++;
 377
 378     return tex;
 379 }
 380
 381 GLuint GLClientState::getBoundTexture(GLenum target) const
 382 {
 383     switch (target) {
 384     case GL_TEXTURE_2D:
 385         return m_tex.activeUnit->texture[TEXTURE_2D];
 386     case GL_TEXTURE_EXTERNAL_OES:
 387         return m_tex.activeUnit->texture[TEXTURE_EXTERNAL];
 388     default:
 389         return 0;
 390     }
 391 }
 392
 393 void GLClientState::deleteTextures(GLsizei n, const GLuint* textures)
 394 {
 395     // Updating the textures array could be made more efficient when deleting
 396     // several textures:
 397     // - compacting the array could be done in a single pass once the deleted
 398     //   textures are marked, or
 399     // - could swap deleted textures to the end and re-sort.
 400     TextureRec* texrec;
 401     for (const GLuint* texture = textures; texture != textures + n; texture++) {
 402         texrec = (TextureRec*)bsearch(texture, m_tex.textures,
 403                 m_tex.numTextures, sizeof(TextureRec), compareTexId);
 404         if (texrec) {
 405             const TextureRec* end = m_tex.textures + m_tex.numTextures;
 406             memmove(texrec, texrec + 1,
 407                     (end - texrec - 1) * sizeof(TextureRec));
 408             m_tex.numTextures--;
 409
 410             for (TextureUnit* unit = m_tex.unit;
 411                  unit != m_tex.unit + MAX_TEXTURE_UNITS;
 412                  unit++)
 413             {
 414                 if (unit->texture[TEXTURE_2D] == *texture) {
 415                     unit->texture[TEXTURE_2D] = 0;
 416                 } else if (unit->texture[TEXTURE_EXTERNAL] == *texture) {
 417                     unit->texture[TEXTURE_EXTERNAL] = 0;
 418                 }
 419             }
 420         }
 421     }
 422 }