src/type3_AndroidCloud/anbox-master/android/opengl/shared/OpenglCodecCommon/GLSharedGroup.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
  17 #include "GLSharedGroup.h"
  18
  19 /**** KeyedVector utilities ****/
  20
  21 template <typename T>
  22 static void clearObjectMap(android::DefaultKeyedVector<GLuint, T>& v) {
  23     for (size_t i = 0; i < v.size(); i++)
  24         delete v.valueAt(i);
  25     v.clear();
  26 }
  27
  28 /**** BufferData ****/
  29
  30 BufferData::BufferData() : m_size(0) {};
  31 BufferData::BufferData(GLsizeiptr size, void * data) : m_size(size)
  32 {
  33     void * buffer = NULL;
  34     if (size>0) buffer = m_fixedBuffer.alloc(size);
  35     if (data) memcpy(buffer, data, size);
  36 }
  37
  38 /**** ProgramData ****/
  39 ProgramData::ProgramData() : m_numIndexes(0),
  40                              m_initialized(false),
  41                              m_locShiftWAR(false)
  42 {
  43     m_Indexes = NULL;
  44 }
  45
  46 void ProgramData::initProgramData(GLuint numIndexes)
  47 {
  48     m_initialized = true;
  49     m_numIndexes = numIndexes;
  50     delete[] m_Indexes;
  51     m_Indexes = new IndexInfo[numIndexes];
  52     m_locShiftWAR = false;
  53 }
  54
  55 bool ProgramData::isInitialized()
  56 {
  57     return m_initialized;
  58 }
  59
  60 ProgramData::~ProgramData()
  61 {
  62     delete[] m_Indexes;
  63     m_Indexes = NULL;
  64 }
  65
  66 void ProgramData::setIndexInfo(GLuint index, GLint base, GLint size, GLenum type)
  67 {
  68     if (index>=m_numIndexes)
  69         return;
  70     m_Indexes[index].base = base;
  71     m_Indexes[index].size = size;
  72     m_Indexes[index].type = type;
  73     if (index > 0) {
  74         m_Indexes[index].appBase = m_Indexes[index-1].appBase +
  75                                    m_Indexes[index-1].size;
  76     }
  77     else {
  78         m_Indexes[index].appBase = 0;
  79     }
  80     m_Indexes[index].hostLocsPerElement = 1;
  81     m_Indexes[index].flags = 0;
  82     m_Indexes[index].samplerValue = 0;
  83 }
  84
  85 void ProgramData::setIndexFlags(GLuint index, GLuint flags)
  86 {
  87     if (index >= m_numIndexes)
  88         return;
  89     m_Indexes[index].flags |= flags;
  90 }
  91
  92 GLuint ProgramData::getIndexForLocation(GLint location)
  93 {
  94     GLuint index = m_numIndexes;
  95     GLint minDist = -1;
  96     for (GLuint i=0;i<m_numIndexes;++i)
  97     {
  98         GLint dist = location - m_Indexes[i].base;
  99         if (dist >= 0 &&
 100             (minDist < 0 || dist < minDist)) {
 101             index = i;
 102             minDist = dist;
 103         }
 104     }
 105     return index;
 106 }
 107
 108 GLenum ProgramData::getTypeForLocation(GLint location)
 109 {
 110     GLuint index = getIndexForLocation(location);
 111     if (index<m_numIndexes) {
 112         return m_Indexes[index].type;
 113     }
 114     return 0;
 115 }
 116
 117 void ProgramData::setupLocationShiftWAR()
 118 {
 119     m_locShiftWAR = false;
 120     for (GLuint i=0; i<m_numIndexes; i++) {
 121         if (0 != (m_Indexes[i].base & 0xffff)) {
 122             return;
 123         }
 124     }
 125     // if we have one uniform at location 0, we do not need the WAR.
 126     if (m_numIndexes > 1) {
 127         m_locShiftWAR = true;
 128     }
 129 }
 130
 131 GLint ProgramData::locationWARHostToApp(GLint hostLoc, GLint arrIndex)
 132 {
 133     if (!m_locShiftWAR) return hostLoc;
 134
 135     GLuint index = getIndexForLocation(hostLoc);
 136     if (index<m_numIndexes) {
 137         if (arrIndex > 0) {
 138             m_Indexes[index].hostLocsPerElement =
 139                               (hostLoc - m_Indexes[index].base) / arrIndex;
 140         }
 141         return m_Indexes[index].appBase + arrIndex;
 142     }
 143     return -1;
 144 }
 145
 146 GLint ProgramData::locationWARAppToHost(GLint appLoc)
 147 {
 148     if (!m_locShiftWAR) return appLoc;
 149
 150     for(GLuint i=0; i<m_numIndexes; i++) {
 151         GLint elemIndex = appLoc - m_Indexes[i].appBase;
 152         if (elemIndex >= 0 && elemIndex < m_Indexes[i].size) {
 153             return m_Indexes[i].base +
 154                    elemIndex * m_Indexes[i].hostLocsPerElement;
 155         }
 156     }
 157     return -1;
 158 }
 159
 160 GLint ProgramData::getNextSamplerUniform(GLint index, GLint* val, GLenum* target)
 161 {
 162     for (GLint i = index + 1; i >= 0 && i < (GLint)m_numIndexes; i++) {
 163         if (m_Indexes[i].type == GL_SAMPLER_2D) {
 164             if (val) *val = m_Indexes[i].samplerValue;
 165             if (target) {
 166                 if (m_Indexes[i].flags & INDEX_FLAG_SAMPLER_EXTERNAL) {
 167                     *target = GL_TEXTURE_EXTERNAL_OES;
 168                 } else {
 169                     *target = GL_TEXTURE_2D;
 170                 }
 171             }
 172             return i;
 173         }
 174     }
 175     return -1;
 176 }
 177
 178 bool ProgramData::setSamplerUniform(GLint appLoc, GLint val, GLenum* target)
 179 {
 180     for (GLuint i = 0; i < m_numIndexes; i++) {
 181         GLint elemIndex = appLoc - m_Indexes[i].appBase;
 182         if (elemIndex >= 0 && elemIndex < m_Indexes[i].size) {
 183             if (m_Indexes[i].type == GL_TEXTURE_2D) {
 184                 m_Indexes[i].samplerValue = val;
 185                 if (target) {
 186                     if (m_Indexes[i].flags & INDEX_FLAG_SAMPLER_EXTERNAL) {
 187                         *target = GL_TEXTURE_EXTERNAL_OES;
 188                     } else {
 189                         *target = GL_TEXTURE_2D;
 190                     }
 191                 }
 192                 return true;
 193             }
 194         }
 195     }
 196     return false;
 197 }
 198
 199 bool ProgramData::attachShader(GLuint shader)
 200 {
 201     size_t n = m_shaders.size();
 202     for (size_t i = 0; i < n; i++) {
 203         if (m_shaders[i] == shader) {
 204             return false;
 205         }
 206     }
 207     // AKA m_shaders.push_back(), but that has an ambiguous call to insertAt()
 208     // due to the default parameters. This is the desired insertAt() overload.
 209     m_shaders.insertAt(shader, m_shaders.size(), 1);
 210     return true;
 211 }
 212
 213 bool ProgramData::detachShader(GLuint shader)
 214 {
 215     size_t n = m_shaders.size();
 216     for (size_t i = 0; i < n; i++) {
 217         if (m_shaders[i] == shader) {
 218             m_shaders.removeAt(i);
 219             return true;
 220         }
 221     }
 222     return false;
 223 }
 224
 225 /***** GLSharedGroup ****/
 226
 227 GLSharedGroup::GLSharedGroup() :
 228     m_buffers(android::DefaultKeyedVector<GLuint, BufferData*>(NULL)),
 229     m_programs(android::DefaultKeyedVector<GLuint, ProgramData*>(NULL)),
 230     m_shaders(android::DefaultKeyedVector<GLuint, ShaderData*>(NULL))
 231 {
 232 }
 233
 234 GLSharedGroup::~GLSharedGroup()
 235 {
 236     m_buffers.clear();
 237     m_programs.clear();
 238     clearObjectMap(m_buffers);
 239     clearObjectMap(m_programs);
 240     clearObjectMap(m_shaders);
 241 }
 242
 243 bool GLSharedGroup::isObject(GLuint obj)
 244 {
 245     android::AutoMutex _lock(m_lock);
 246     return ((m_shaders.valueFor(obj)!=NULL) || (m_programs.valueFor(obj)!=NULL));
 247 }
 248
 249 BufferData * GLSharedGroup::getBufferData(GLuint bufferId)
 250 {
 251     android::AutoMutex _lock(m_lock);
 252     return m_buffers.valueFor(bufferId);
 253 }
 254
 255 void GLSharedGroup::addBufferData(GLuint bufferId, GLsizeiptr size, void * data)
 256 {
 257     android::AutoMutex _lock(m_lock);
 258     m_buffers.add(bufferId, new BufferData(size, data));
 259 }
 260
 261 void GLSharedGroup::updateBufferData(GLuint bufferId, GLsizeiptr size, void * data)
 262 {
 263     android::AutoMutex _lock(m_lock);
 264     ssize_t idx = m_buffers.indexOfKey(bufferId);
 265     if (idx >= 0) {
 266         delete m_buffers.valueAt(idx);
 267         m_buffers.editValueAt(idx) = new BufferData(size, data);
 268     } else {
 269         m_buffers.add(bufferId, new BufferData(size, data));
 270     }
 271 }
 272
 273 GLenum GLSharedGroup::subUpdateBufferData(GLuint bufferId, GLintptr offset, GLsizeiptr size, void * data)
 274 {
 275     android::AutoMutex _lock(m_lock);
 276     BufferData * buf = m_buffers.valueFor(bufferId);
 277     if ((!buf) || (buf->m_size < offset+size) || (offset < 0) || (size<0)) return GL_INVALID_VALUE;
 278
 279     //it's safe to update now
 280     memcpy((char*)buf->m_fixedBuffer.ptr() + offset, data, size);
 281     return GL_NO_ERROR;
 282 }
 283
 284 void GLSharedGroup::deleteBufferData(GLuint bufferId)
 285 {
 286     android::AutoMutex _lock(m_lock);
 287     ssize_t idx = m_buffers.indexOfKey(bufferId);
 288     if (idx >= 0) {
 289         delete m_buffers.valueAt(idx);
 290         m_buffers.removeItemsAt(idx);
 291     }
 292 }
 293
 294 void GLSharedGroup::addProgramData(GLuint program)
 295 {
 296     android::AutoMutex _lock(m_lock);
 297     ProgramData *pData = m_programs.valueFor(program);
 298     if (pData)
 299     {
 300         m_programs.removeItem(program);
 301         delete pData;
 302     }
 303
 304     m_programs.add(program,new ProgramData());
 305 }
 306
 307 void GLSharedGroup::initProgramData(GLuint program, GLuint numIndexes)
 308 {
 309     android::AutoMutex _lock(m_lock);
 310     ProgramData *pData = m_programs.valueFor(program);
 311     if (pData)
 312     {
 313         pData->initProgramData(numIndexes);
 314     }
 315 }
 316
 317 bool GLSharedGroup::isProgramInitialized(GLuint program)
 318 {
 319     android::AutoMutex _lock(m_lock);
 320     ProgramData* pData = m_programs.valueFor(program);
 321     if (pData)
 322     {
 323         return pData->isInitialized();
 324     }
 325     return false;
 326 }
 327
 328 void GLSharedGroup::deleteProgramData(GLuint program)
 329 {
 330     android::AutoMutex _lock(m_lock);
 331     ProgramData *pData = m_programs.valueFor(program);
 332     if (pData)
 333         delete pData;
 334     m_programs.removeItem(program);
 335 }
 336
 337 void GLSharedGroup::attachShader(GLuint program, GLuint shader)
 338 {
 339     android::AutoMutex _lock(m_lock);
 340     ProgramData* programData = m_programs.valueFor(program);
 341     ssize_t idx = m_shaders.indexOfKey(shader);
 342     if (programData && idx >= 0) {
 343         if (programData->attachShader(shader)) {
 344             refShaderDataLocked(idx);
 345         }
 346     }
 347 }
 348
 349 void GLSharedGroup::detachShader(GLuint program, GLuint shader)
 350 {
 351     android::AutoMutex _lock(m_lock);
 352     ProgramData* programData = m_programs.valueFor(program);
 353     ssize_t idx = m_shaders.indexOfKey(shader);
 354     if (programData && idx >= 0) {
 355         if (programData->detachShader(shader)) {
 356             unrefShaderDataLocked(idx);
 357         }
 358     }
 359 }
 360
 361 void GLSharedGroup::setProgramIndexInfo(GLuint program, GLuint index, GLint base, GLint size, GLenum type, const char* name)
 362 {
 363     android::AutoMutex _lock(m_lock);
 364     ProgramData* pData = m_programs.valueFor(program);
 365     if (pData)
 366     {
 367         pData->setIndexInfo(index,base,size,type);
 368
 369         if (type == GL_SAMPLER_2D) {
 370             size_t n = pData->getNumShaders();
 371             for (size_t i = 0; i < n; i++) {
 372                 GLuint shaderId = pData->getShader(i);
 373                 ShaderData* shader = m_shaders.valueFor(shaderId);
 374                 if (!shader) continue;
 375                 ShaderData::StringList::iterator nameIter = shader->samplerExternalNames.begin();
 376                 ShaderData::StringList::iterator nameEnd  = shader->samplerExternalNames.end();
 377                 while (nameIter != nameEnd) {
 378                     if (*nameIter == name) {
 379                         pData->setIndexFlags(index, ProgramData::INDEX_FLAG_SAMPLER_EXTERNAL);
 380                         break;
 381                     }
 382                     ++nameIter;
 383                 }
 384             }
 385         }
 386     }
 387 }
 388
 389 GLenum GLSharedGroup::getProgramUniformType(GLuint program, GLint location)
 390 {
 391     android::AutoMutex _lock(m_lock);
 392     ProgramData* pData = m_programs.valueFor(program);
 393     GLenum type=0;
 394     if (pData)
 395     {
 396         type = pData->getTypeForLocation(location);
 397     }
 398     return type;
 399 }
 400
 401 bool  GLSharedGroup::isProgram(GLuint program)
 402 {
 403     android::AutoMutex _lock(m_lock);
 404     ProgramData* pData = m_programs.valueFor(program);
 405     return (pData!=NULL);
 406 }
 407
 408 void GLSharedGroup::setupLocationShiftWAR(GLuint program)
 409 {
 410     android::AutoMutex _lock(m_lock);
 411     ProgramData* pData = m_programs.valueFor(program);
 412     if (pData) pData->setupLocationShiftWAR();
 413 }
 414
 415 GLint GLSharedGroup::locationWARHostToApp(GLuint program, GLint hostLoc, GLint arrIndex)
 416 {
 417     android::AutoMutex _lock(m_lock);
 418     ProgramData* pData = m_programs.valueFor(program);
 419     if (pData) return pData->locationWARHostToApp(hostLoc, arrIndex);
 420     else return hostLoc;
 421 }
 422
 423 GLint GLSharedGroup::locationWARAppToHost(GLuint program, GLint appLoc)
 424 {
 425     android::AutoMutex _lock(m_lock);
 426     ProgramData* pData = m_programs.valueFor(program);
 427     if (pData) return pData->locationWARAppToHost(appLoc);
 428     else return appLoc;
 429 }
 430
 431 bool GLSharedGroup::needUniformLocationWAR(GLuint program)
 432 {
 433     android::AutoMutex _lock(m_lock);
 434     ProgramData* pData = m_programs.valueFor(program);
 435     if (pData) return pData->needUniformLocationWAR();
 436     return false;
 437 }
 438
 439 GLint GLSharedGroup::getNextSamplerUniform(GLuint program, GLint index, GLint* val, GLenum* target) const
 440 {
 441     android::AutoMutex _lock(m_lock);
 442     ProgramData* pData = m_programs.valueFor(program);
 443     return pData ? pData->getNextSamplerUniform(index, val, target) : -1;
 444 }
 445
 446 bool GLSharedGroup::setSamplerUniform(GLuint program, GLint appLoc, GLint val, GLenum* target)
 447 {
 448     android::AutoMutex _lock(m_lock);
 449     ProgramData* pData = m_programs.valueFor(program);
 450     return pData ? pData->setSamplerUniform(appLoc, val, target) : false;
 451 }
 452
 453 bool GLSharedGroup::addShaderData(GLuint shader)
 454 {
 455     android::AutoMutex _lock(m_lock);
 456     ShaderData* data = new ShaderData;
 457     if (data) {
 458         if (m_shaders.add(shader, data) < 0) {
 459             delete data;
 460             data = NULL;
 461         }
 462         data->refcount = 1;
 463     }
 464     return data != NULL;
 465 }
 466
 467 ShaderData* GLSharedGroup::getShaderData(GLuint shader)
 468 {
 469     android::AutoMutex _lock(m_lock);
 470     return m_shaders.valueFor(shader);
 471 }
 472
 473 void GLSharedGroup::unrefShaderData(GLuint shader)
 474 {
 475     android::AutoMutex _lock(m_lock);
 476     ssize_t idx = m_shaders.indexOfKey(shader);
 477     if (idx >= 0) {
 478         unrefShaderDataLocked(idx);
 479     }
 480 }
 481
 482 void GLSharedGroup::refShaderDataLocked(ssize_t shaderIdx)
 483 {
 484     assert(shaderIdx >= 0 && shaderIdx <= m_shaders.size());
 485     ShaderData* data = m_shaders.valueAt(shaderIdx);
 486     data->refcount++;
 487 }
 488
 489 void GLSharedGroup::unrefShaderDataLocked(ssize_t shaderIdx)
 490 {
 491     assert(shaderIdx >= 0 && shaderIdx <= m_shaders.size());
 492     ShaderData* data = m_shaders.valueAt(shaderIdx);
 493     if (--data->refcount == 0) {
 494         delete data;
 495         m_shaders.removeItemsAt(shaderIdx);
 496     }
 497 }