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 #include "KeyedVectorUtils.h"
20
21 /**** BufferData ****/
22
BufferData()23 BufferData::BufferData() : m_size(0), m_usage(0), m_mapped(false) {};
24
BufferData(GLsizeiptr size,const void * data)25 BufferData::BufferData(GLsizeiptr size, const void* data) :
26 m_size(size), m_usage(0), m_mapped(false) {
27
28 void * buffer = NULL;
29
30 if (size>0) buffer = m_fixedBuffer.alloc(size);
31
32 if (data) memcpy(buffer, data, size);
33 }
34
35 /**** ProgramData ****/
ProgramData()36 ProgramData::ProgramData() : m_numIndexes(0),
37 m_initialized(false),
38 m_locShiftWAR(false) {
39 m_Indexes = NULL;
40 }
41
initProgramData(GLuint numIndexes)42 void ProgramData::initProgramData(GLuint numIndexes) {
43 m_initialized = true;
44 m_numIndexes = numIndexes;
45
46 delete [] m_Indexes;
47
48 m_Indexes = new IndexInfo[numIndexes];
49 m_locShiftWAR = false;
50 }
51
isInitialized()52 bool ProgramData::isInitialized() {
53 return m_initialized;
54 }
55
~ProgramData()56 ProgramData::~ProgramData() {
57
58 delete [] m_Indexes;
59
60 m_Indexes = NULL;
61 }
62
setIndexInfo(GLuint index,GLint base,GLint size,GLenum type)63 void ProgramData::setIndexInfo(
64 GLuint index, GLint base, GLint size, GLenum type) {
65
66 if (index >= m_numIndexes) return;
67
68 m_Indexes[index].base = base;
69 m_Indexes[index].size = size;
70 m_Indexes[index].type = type;
71
72 if (index > 0) {
73 m_Indexes[index].appBase = m_Indexes[index-1].appBase +
74 m_Indexes[index-1].size;
75 } else {
76 m_Indexes[index].appBase = 0;
77 }
78
79 m_Indexes[index].hostLocsPerElement = 1;
80 m_Indexes[index].flags = 0;
81 m_Indexes[index].samplerValue = 0;
82 }
83
setIndexFlags(GLuint index,GLuint flags)84 void ProgramData::setIndexFlags(GLuint index, GLuint flags) {
85
86 if (index >= m_numIndexes) return;
87
88 m_Indexes[index].flags |= flags;
89 }
90
getIndexForLocation(GLint location)91 GLuint ProgramData::getIndexForLocation(GLint location) {
92 GLuint index = m_numIndexes;
93
94 GLint minDist = -1;
95
96 for (GLuint i = 0; i < m_numIndexes; ++i) {
97 GLint dist = location - m_Indexes[i].base;
98 if (dist >= 0 && (minDist < 0 || dist < minDist)) {
99 index = i;
100 minDist = dist;
101 }
102 }
103
104 return index;
105 }
106
getTypeForLocation(GLint location)107 GLenum ProgramData::getTypeForLocation(GLint location) {
108 GLuint index = getIndexForLocation(location);
109 if (index < m_numIndexes) {
110 return m_Indexes[index].type;
111 }
112 return 0;
113 }
114
setupLocationShiftWAR()115 void ProgramData::setupLocationShiftWAR() {
116 m_locShiftWAR = false;
117 for (GLuint i= 0; i < m_numIndexes; i++) {
118 if (0 != (m_Indexes[i].base & 0xffff)) {
119 return;
120 }
121 }
122
123 // if we have one uniform at location 0, we do not need the WAR.
124 if (m_numIndexes > 1) m_locShiftWAR = true;
125 }
126
locationWARHostToApp(GLint hostLoc,GLint arrIndex)127 GLint ProgramData::locationWARHostToApp(GLint hostLoc, GLint arrIndex) {
128
129 if (!m_locShiftWAR) return hostLoc;
130
131 GLuint index = getIndexForLocation(hostLoc);
132
133 if (index < m_numIndexes) {
134 if (arrIndex > 0) {
135 m_Indexes[index].hostLocsPerElement =
136 (hostLoc - m_Indexes[index].base) / arrIndex;
137 }
138 return m_Indexes[index].appBase + arrIndex;
139 }
140
141 return -1;
142 }
143
locationWARAppToHost(GLint appLoc)144 GLint ProgramData::locationWARAppToHost(GLint appLoc) {
145
146 if (!m_locShiftWAR) return appLoc;
147
148 for (GLuint i = 0; i < m_numIndexes; i++) {
149 GLint elemIndex =
150 appLoc - m_Indexes[i].appBase;
151
152 if (elemIndex >= 0 && elemIndex < m_Indexes[i].size) {
153 return m_Indexes[i].base +
154 elemIndex * m_Indexes[i].hostLocsPerElement;
155 }
156 }
157
158 return -1;
159 }
160
getNextSamplerUniform(GLint index,GLint * val,GLenum * target)161 GLint ProgramData::getNextSamplerUniform(
162 GLint index, GLint* val, GLenum* target) {
163
164 for (GLint i = index + 1; i >= 0 && i < (GLint)m_numIndexes; i++) {
165
166 if (m_Indexes[i].type == GL_SAMPLER_2D) {
167
168 if (val) *val = m_Indexes[i].samplerValue;
169
170 if (target) {
171 if (m_Indexes[i].flags & INDEX_FLAG_SAMPLER_EXTERNAL) {
172 *target = GL_TEXTURE_EXTERNAL_OES;
173 } else {
174 *target = GL_TEXTURE_2D;
175 }
176 }
177
178 return i;
179 }
180
181 }
182
183 return -1;
184 }
185
setSamplerUniform(GLint appLoc,GLint val,GLenum * target)186 bool ProgramData::setSamplerUniform(GLint appLoc, GLint val, GLenum* target) {
187
188 for (GLuint i = 0; i < m_numIndexes; i++) {
189
190 GLint elemIndex = appLoc - m_Indexes[i].appBase;
191
192 if (elemIndex >= 0 && elemIndex < m_Indexes[i].size) {
193 if (m_Indexes[i].type == GL_SAMPLER_2D) {
194 m_Indexes[i].samplerValue = val;
195 if (target) {
196 if (m_Indexes[i].flags & INDEX_FLAG_SAMPLER_EXTERNAL) {
197 *target = GL_TEXTURE_EXTERNAL_OES;
198 } else {
199 *target = GL_TEXTURE_2D;
200
201 }
202 }
203 return true;
204 }
205 }
206 }
207
208 return false;
209 }
210
attachShader(GLuint shader)211 bool ProgramData::attachShader(GLuint shader) {
212 size_t n = m_shaders.size();
213
214 for (size_t i = 0; i < n; i++) {
215 if (m_shaders[i] == shader) {
216 return false;
217 }
218 }
219 m_shaders.push_back(shader);
220 return true;
221 }
222
detachShader(GLuint shader)223 bool ProgramData::detachShader(GLuint shader) {
224 size_t n = m_shaders.size();
225
226 for (size_t i = 0; i < n; i++) {
227 if (m_shaders[i] == shader) {
228 m_shaders.erase(m_shaders.begin() + i);
229 return true;
230 }
231 }
232
233 return false;
234 }
235
236 /***** GLSharedGroup ****/
237
GLSharedGroup()238 GLSharedGroup::GLSharedGroup() { }
239
~GLSharedGroup()240 GLSharedGroup::~GLSharedGroup() {
241 m_buffers.clear();
242 m_programs.clear();
243 clearObjectMap(m_buffers);
244 clearObjectMap(m_programs);
245 clearObjectMap(m_shaders);
246 clearObjectMap(m_shaderPrograms);
247 }
248
isShaderOrProgramObject(GLuint obj)249 bool GLSharedGroup::isShaderOrProgramObject(GLuint obj) {
250
251 android::AutoMutex _lock(m_lock);
252
253 return (findObjectOrDefault(m_shaders, obj) ||
254 findObjectOrDefault(m_programs, obj) ||
255 findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[obj]));
256 }
257
getBufferData(GLuint bufferId)258 BufferData* GLSharedGroup::getBufferData(GLuint bufferId) {
259
260 android::AutoMutex _lock(m_lock);
261
262 return findObjectOrDefault(m_buffers, bufferId);
263 }
264
getTextureData()265 SharedTextureDataMap* GLSharedGroup::getTextureData() {
266 return &m_textureRecs;
267 }
268
addBufferData(GLuint bufferId,GLsizeiptr size,const void * data)269 void GLSharedGroup::addBufferData(GLuint bufferId, GLsizeiptr size, const void* data) {
270
271 android::AutoMutex _lock(m_lock);
272
273 m_buffers[bufferId] = new BufferData(size, data);
274 }
275
updateBufferData(GLuint bufferId,GLsizeiptr size,const void * data)276 void GLSharedGroup::updateBufferData(GLuint bufferId, GLsizeiptr size, const void* data) {
277
278 android::AutoMutex _lock(m_lock);
279
280 BufferData* currentBuffer = findObjectOrDefault(m_buffers, bufferId);
281
282 if (currentBuffer) delete currentBuffer;
283
284 m_buffers[bufferId] = new BufferData(size, data);
285 }
286
setBufferUsage(GLuint bufferId,GLenum usage)287 void GLSharedGroup::setBufferUsage(GLuint bufferId, GLenum usage) {
288
289 android::AutoMutex _lock(m_lock);
290
291 BufferData* data = findObjectOrDefault(m_buffers, bufferId);
292
293 if (data) data->m_usage = usage;
294 }
295
setBufferMapped(GLuint bufferId,bool mapped)296 void GLSharedGroup::setBufferMapped(GLuint bufferId, bool mapped) {
297 BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
298
299 if (!buf) return;
300
301 buf->m_mapped = mapped;
302 }
303
getBufferUsage(GLuint bufferId)304 GLenum GLSharedGroup::getBufferUsage(GLuint bufferId) {
305 BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
306
307 if (!buf) return 0;
308
309 return buf->m_usage;
310 }
311
isBufferMapped(GLuint bufferId)312 bool GLSharedGroup::isBufferMapped(GLuint bufferId) {
313 BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
314
315 if (!buf) return false;
316
317 return buf->m_mapped;
318 }
319
subUpdateBufferData(GLuint bufferId,GLintptr offset,GLsizeiptr size,const void * data)320 GLenum GLSharedGroup::subUpdateBufferData(GLuint bufferId, GLintptr offset, GLsizeiptr size, const void* data) {
321
322 android::AutoMutex _lock(m_lock);
323
324 BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
325
326 if ((!buf) || (buf->m_size < offset+size) || (offset < 0) || (size<0)) {
327 return GL_INVALID_VALUE;
328 }
329
330 memcpy((char*)buf->m_fixedBuffer.ptr() + offset, data, size);
331
332 buf->m_indexRangeCache.invalidateRange((size_t)offset, (size_t)size);
333 return GL_NO_ERROR;
334 }
335
deleteBufferData(GLuint bufferId)336 void GLSharedGroup::deleteBufferData(GLuint bufferId) {
337
338 android::AutoMutex _lock(m_lock);
339
340 BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
341 if (buf) {
342 delete buf;
343 m_buffers.erase(bufferId);
344 }
345 }
346
addProgramData(GLuint program)347 void GLSharedGroup::addProgramData(GLuint program) {
348
349 android::AutoMutex _lock(m_lock);
350
351 ProgramData* pData = findObjectOrDefault(m_programs, program);
352 if (pData) {
353 delete pData;
354 }
355
356 m_programs[program] = new ProgramData();
357 }
358
initProgramData(GLuint program,GLuint numIndexes)359 void GLSharedGroup::initProgramData(GLuint program, GLuint numIndexes) {
360
361 android::AutoMutex _lock(m_lock);
362
363 ProgramData* pData = findObjectOrDefault(m_programs, program);
364 if (pData) {
365 pData->initProgramData(numIndexes);
366 }
367 }
368
isProgramInitialized(GLuint program)369 bool GLSharedGroup::isProgramInitialized(GLuint program) {
370
371 android::AutoMutex _lock(m_lock);
372
373 ProgramData* pData = findObjectOrDefault(m_programs, program);
374
375 if (pData) {
376 return pData->isInitialized();
377 }
378
379 if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) {
380 return false;
381 }
382
383 ShaderProgramData* shaderProgramData =
384 findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
385
386 if (shaderProgramData) {
387 return shaderProgramData->programData.isInitialized();
388 }
389
390 return false;
391 }
392
deleteProgramData(GLuint program)393 void GLSharedGroup::deleteProgramData(GLuint program) {
394
395 android::AutoMutex _lock(m_lock);
396
397 ProgramData* pData = findObjectOrDefault(m_programs, program);
398
399 if (pData) delete pData;
400
401 m_programs.erase(program);
402
403 if (m_shaderProgramIdMap.find(program) ==
404 m_shaderProgramIdMap.end()) return;
405
406 ShaderProgramData* spData =
407 findObjectOrDefault(
408 m_shaderPrograms, m_shaderProgramIdMap[program]);
409
410 if (spData) delete spData;
411
412 m_shaderPrograms.erase(m_shaderProgramIdMap[program]);
413 m_shaderProgramIdMap.erase(program);
414 }
415
416 // No such thing for separable shader programs.
attachShader(GLuint program,GLuint shader)417 void GLSharedGroup::attachShader(GLuint program, GLuint shader) {
418
419 android::AutoMutex _lock(m_lock);
420
421 ProgramData* pData = findObjectOrDefault(m_programs, program);
422 ShaderData* sData = findObjectOrDefault(m_shaders, shader);
423
424 if (pData && sData) {
425 if (pData->attachShader(shader)) {
426 refShaderDataLocked(shader);
427 }
428 }
429 }
430
detachShader(GLuint program,GLuint shader)431 void GLSharedGroup::detachShader(GLuint program, GLuint shader) {
432
433 android::AutoMutex _lock(m_lock);
434
435 ProgramData* pData = findObjectOrDefault(m_programs, program);
436 ShaderData* sData = findObjectOrDefault(m_shaders, shader);
437 if (pData && sData) {
438 if (pData->detachShader(shader)) {
439 unrefShaderDataLocked(shader);
440 }
441 }
442 }
443
444 // Not needed/used for separate shader programs.
setProgramIndexInfo(GLuint program,GLuint index,GLint base,GLint size,GLenum type,const char * name)445 void GLSharedGroup::setProgramIndexInfo(
446 GLuint program, GLuint index, GLint base,
447 GLint size, GLenum type, const char* name) {
448
449 android::AutoMutex _lock(m_lock);
450
451 ProgramData* pData = findObjectOrDefault(m_programs, program);
452
453 if (pData) {
454 pData->setIndexInfo(index,base,size,type);
455 if (type == GL_SAMPLER_2D) {
456 size_t n = pData->getNumShaders();
457 for (size_t i = 0; i < n; i++) {
458 GLuint shaderId = pData->getShader(i);
459 ShaderData* shader = findObjectOrDefault(m_shaders, shaderId);
460 if (!shader) continue;
461 ShaderData::StringList::iterator nameIter =
462 shader->samplerExternalNames.begin();
463 ShaderData::StringList::iterator nameEnd =
464 shader->samplerExternalNames.end();
465 while (nameIter != nameEnd) {
466 if (*nameIter == name) {
467 pData->setIndexFlags(
468 index,
469 ProgramData::INDEX_FLAG_SAMPLER_EXTERNAL);
470 break;
471 }
472 ++nameIter;
473 }
474 }
475 }
476 }
477 }
478
getProgramUniformType(GLuint program,GLint location)479 GLenum GLSharedGroup::getProgramUniformType(GLuint program, GLint location) {
480
481 android::AutoMutex _lock(m_lock);
482
483 ProgramData* pData = findObjectOrDefault(m_programs, program);
484 GLenum type = 0;
485
486 if (pData) {
487 type = pData->getTypeForLocation(location);
488 }
489
490 if (m_shaderProgramIdMap.find(program) ==
491 m_shaderProgramIdMap.end()) return type;
492
493 ShaderProgramData* spData =
494 findObjectOrDefault(
495 m_shaderPrograms, m_shaderProgramIdMap[program]);
496
497 if (spData) {
498 type = spData->programData.getTypeForLocation(location);
499 }
500
501 return type;
502 }
503
isProgram(GLuint program)504 bool GLSharedGroup::isProgram(GLuint program) {
505
506 android::AutoMutex _lock(m_lock);
507
508 ProgramData* pData = findObjectOrDefault(m_programs, program);
509
510 if (pData) return true;
511
512 if (m_shaderProgramIdMap.find(program) ==
513 m_shaderProgramIdMap.end()) return false;
514
515 ShaderProgramData* spData =
516 findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
517
518 if (spData) return true;
519
520 return false;
521 }
522
setupLocationShiftWAR(GLuint program)523 void GLSharedGroup::setupLocationShiftWAR(GLuint program) {
524
525 android::AutoMutex _lock(m_lock);
526
527 ProgramData* pData =
528 findObjectOrDefault(m_programs, program);
529
530 if (pData) pData->setupLocationShiftWAR();
531 }
532
locationWARHostToApp(GLuint program,GLint hostLoc,GLint arrIndex)533 GLint GLSharedGroup::locationWARHostToApp(
534 GLuint program, GLint hostLoc, GLint arrIndex) {
535
536 android::AutoMutex _lock(m_lock);
537
538 ProgramData* pData = findObjectOrDefault(m_programs, program);
539
540 if (pData) return pData->locationWARHostToApp(hostLoc, arrIndex);
541
542 if (m_shaderProgramIdMap.find(program) ==
543 m_shaderProgramIdMap.end()) return hostLoc;
544
545 ShaderProgramData* spData =
546 findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
547
548 if (spData) return spData->programData.locationWARHostToApp(hostLoc, arrIndex);
549
550 return hostLoc;
551 }
552
locationWARAppToHost(GLuint program,GLint appLoc)553 GLint GLSharedGroup::locationWARAppToHost(GLuint program, GLint appLoc) {
554
555 android::AutoMutex _lock(m_lock);
556
557 ProgramData* pData =
558 findObjectOrDefault(m_programs, program);
559
560 if (pData) return pData->locationWARAppToHost(appLoc);
561
562 if (m_shaderProgramIdMap.find(program) ==
563 m_shaderProgramIdMap.end()) return appLoc;
564
565 ShaderProgramData* spData =
566 findObjectOrDefault(
567 m_shaderPrograms, m_shaderProgramIdMap[program]);
568
569 if (spData) return spData->programData.locationWARAppToHost(appLoc);
570
571 return appLoc;
572 }
573
needUniformLocationWAR(GLuint program)574 bool GLSharedGroup::needUniformLocationWAR(GLuint program) {
575
576 android::AutoMutex _lock(m_lock);
577
578 ProgramData* pData =
579 findObjectOrDefault(m_programs, program);
580
581 if (pData) return pData->needUniformLocationWAR();
582
583 if (m_shaderProgramIdMap.find(program) ==
584 m_shaderProgramIdMap.end()) return false;
585
586 ShaderProgramData* spData =
587 findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
588
589 if (spData) return spData->programData.needUniformLocationWAR();
590
591 return false;
592 }
593
getNextSamplerUniform(GLuint program,GLint index,GLint * val,GLenum * target) const594 GLint GLSharedGroup::getNextSamplerUniform(
595 GLuint program, GLint index, GLint* val, GLenum* target) const {
596
597 android::AutoMutex _lock(m_lock);
598
599 ProgramData* pData = findObjectOrDefault(m_programs, program);
600
601 if (pData) return pData->getNextSamplerUniform(index, val, target);
602
603 if (m_shaderProgramIdMap.find(program) ==
604 m_shaderProgramIdMap.end()) return -1;
605
606 ShaderProgramData* spData =
607 findObjectOrDefault(
608 m_shaderPrograms,
609 findObjectOrDefault(m_shaderProgramIdMap, program));
610
611 if (spData) return spData->programData.getNextSamplerUniform(index, val, target);
612
613 return -1;
614 }
615
setSamplerUniform(GLuint program,GLint appLoc,GLint val,GLenum * target)616 bool GLSharedGroup::setSamplerUniform(
617 GLuint program, GLint appLoc, GLint val, GLenum* target) {
618
619 android::AutoMutex _lock(m_lock);
620
621 ProgramData* pData =
622 findObjectOrDefault(m_programs, program);
623
624 if (pData) return pData->setSamplerUniform(appLoc, val, target);
625
626 if (m_shaderProgramIdMap.find(program) ==
627 m_shaderProgramIdMap.end()) return false;
628
629 ShaderProgramData* spData =
630 findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
631
632 if (spData) return spData->programData.setSamplerUniform(appLoc, val, target);
633
634 return false;
635 }
636
isShader(GLuint shader)637 bool GLSharedGroup::isShader(GLuint shader) {
638
639 android::AutoMutex _lock(m_lock);
640
641 ShaderData* pData = findObjectOrDefault(m_shaders, shader);
642
643 return pData != NULL;
644 }
645
addShaderData(GLuint shader)646 bool GLSharedGroup::addShaderData(GLuint shader) {
647
648 android::AutoMutex _lock(m_lock);
649
650 ShaderData* data = new ShaderData;
651
652 if (data) {
653 m_shaders[shader] = data;
654 data->refcount = 1;
655 }
656
657 return data != NULL;
658 }
659
getShaderData(GLuint shader)660 ShaderData* GLSharedGroup::getShaderData(GLuint shader) {
661
662 android::AutoMutex _lock(m_lock);
663
664 return findObjectOrDefault(m_shaders, shader);
665 }
666
unrefShaderData(GLuint shader)667 void GLSharedGroup::unrefShaderData(GLuint shader) {
668
669 android::AutoMutex _lock(m_lock);
670
671 unrefShaderDataLocked(shader);
672 }
673
refShaderDataLocked(GLuint shaderId)674 void GLSharedGroup::refShaderDataLocked(GLuint shaderId) {
675 ShaderData* data = findObjectOrDefault(m_shaders, shaderId);
676 data->refcount++;
677 }
678
unrefShaderDataLocked(GLuint shaderId)679 void GLSharedGroup::unrefShaderDataLocked(GLuint shaderId) {
680 ShaderData* data = findObjectOrDefault(m_shaders, shaderId);
681
682 if (data && --data->refcount == 0) {
683
684 delete data;
685
686 m_shaders.erase(shaderId);
687 }
688 }
689
addNewShaderProgramData()690 uint32_t GLSharedGroup::addNewShaderProgramData() {
691
692 android::AutoMutex _lock(m_lock);
693
694 ShaderProgramData* data = new ShaderProgramData;
695 uint32_t currId = m_shaderProgramId;
696
697 ALOGD("%s: new data %p id %u", __FUNCTION__, data, currId);
698
699 m_shaderPrograms[currId] = data;
700 m_shaderProgramId++;
701 return currId;
702 }
703
associateGLShaderProgram(GLuint shaderProgramName,uint32_t shaderProgramId)704 void GLSharedGroup::associateGLShaderProgram(
705 GLuint shaderProgramName, uint32_t shaderProgramId) {
706
707 android::AutoMutex _lock(m_lock);
708
709 m_shaderProgramIdMap[shaderProgramName] = shaderProgramId;
710 }
711
getShaderProgramDataById(uint32_t id)712 ShaderProgramData* GLSharedGroup::getShaderProgramDataById(uint32_t id) {
713
714 android::AutoMutex _lock(m_lock);
715
716 ShaderProgramData* res = findObjectOrDefault(m_shaderPrograms, id);
717
718 ALOGD("%s: id=%u res=%p", __FUNCTION__, id, res);
719
720 return res;
721 }
722
getShaderProgramData(GLuint shaderProgramName)723 ShaderProgramData* GLSharedGroup::getShaderProgramData(
724 GLuint shaderProgramName) {
725
726 android::AutoMutex _lock(m_lock);
727
728 return findObjectOrDefault(m_shaderPrograms,
729 m_shaderProgramIdMap[shaderProgramName]);
730 }
731
deleteShaderProgramDataById(uint32_t id)732 void GLSharedGroup::deleteShaderProgramDataById(uint32_t id) {
733
734 android::AutoMutex _lock(m_lock);
735
736 ShaderProgramData* data =
737 findObjectOrDefault(m_shaderPrograms, id);
738
739 delete data;
740
741 m_shaderPrograms.erase(id);
742 }
743
744
deleteShaderProgramData(GLuint shaderProgramName)745 void GLSharedGroup::deleteShaderProgramData(GLuint shaderProgramName) {
746
747 android::AutoMutex _lock(m_lock);
748
749 uint32_t id = m_shaderProgramIdMap[shaderProgramName];
750 ShaderProgramData* data = findObjectOrDefault(m_shaderPrograms, id);
751
752 delete data;
753
754 m_shaderPrograms.erase(id);
755 m_shaderProgramIdMap.erase(shaderProgramName);
756 }
757
initShaderProgramData(GLuint shaderProgram,GLuint numIndices)758 void GLSharedGroup::initShaderProgramData(GLuint shaderProgram, GLuint numIndices) {
759 ShaderProgramData* spData = getShaderProgramData(shaderProgram);
760 spData->programData.initProgramData(numIndices);
761 }
762
setShaderProgramIndexInfo(GLuint shaderProgram,GLuint index,GLint base,GLint size,GLenum type,const char * name)763 void GLSharedGroup::setShaderProgramIndexInfo(
764 GLuint shaderProgram, GLuint index, GLint base,
765 GLint size, GLenum type, const char* name) {
766
767 ShaderProgramData* spData = getShaderProgramData(shaderProgram);
768 ProgramData& pData = spData->programData;
769 ShaderData& sData = spData->shaderData;
770
771 pData.setIndexInfo(index, base, size, type);
772
773 if (type == GL_SAMPLER_2D) {
774
775 ShaderData::StringList::iterator nameIter =
776 sData.samplerExternalNames.begin();
777 ShaderData::StringList::iterator nameEnd =
778 sData.samplerExternalNames.end();
779
780 while (nameIter != nameEnd) {
781 if (*nameIter == name) {
782 pData.setIndexFlags(
783 index, ProgramData::INDEX_FLAG_SAMPLER_EXTERNAL);
784 break;
785 }
786 ++nameIter;
787 }
788 }
789 }
790
setupShaderProgramLocationShiftWAR(GLuint shaderProgram)791 void GLSharedGroup::setupShaderProgramLocationShiftWAR(GLuint shaderProgram) {
792 ShaderProgramData* spData = getShaderProgramData(shaderProgram);
793 spData->programData.setupLocationShiftWAR();
794 }
795