blob: 50cb9f9921c6afc80def8a1761f725e7aaca1b78 [file] [log] [blame]
Jason Samsbb51c402009-11-25 13:22:07 -08001/*
Jason Samsfe1d5ff2012-03-23 11:47:26 -07002 * Copyright (C) 2011-2012 The Android Open Source Project
Jason Samsbb51c402009-11-25 13:22:07 -08003 *
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
Alex Sakhartchouk4a36b452011-04-29 16:49:08 -070017#include <rs_hal.h>
18#include <rsContext.h>
19
20#include "rsdShader.h"
21#include "rsdShaderCache.h"
Alex Sakhartchouk407cae92011-05-06 14:59:45 -070022#include "rsdGL.h"
Alex Sakhartchouk4a36b452011-04-29 16:49:08 -070023
Jason Samsbb51c402009-11-25 13:22:07 -080024#include <GLES/gl.h>
25#include <GLES2/gl2.h>
26
27using namespace android;
28using namespace android::renderscript;
29
30
Alex Sakhartchouk4a36b452011-04-29 16:49:08 -070031RsdShaderCache::RsdShaderCache() {
Alex Sakhartchoukfeede2a2010-10-01 10:54:06 -070032 mEntries.setCapacity(16);
Alex Sakhartchouk4a36b452011-04-29 16:49:08 -070033 mVertexDirty = true;
34 mFragmentDirty = true;
Jason Samsbb51c402009-11-25 13:22:07 -080035}
36
Alex Sakhartchouk4a36b452011-04-29 16:49:08 -070037RsdShaderCache::~RsdShaderCache() {
Jason Sams49945c02011-01-05 03:37:48 -080038 cleanupAll();
Jason Samsbb51c402009-11-25 13:22:07 -080039}
40
Alex Sakhartchouk4a36b452011-04-29 16:49:08 -070041void RsdShaderCache::updateUniformArrayData(const Context *rsc, RsdShader *prog, uint32_t linkedID,
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -080042 UniformData *data, const char* logTag,
43 UniformQueryData **uniformList, uint32_t uniListSize) {
44
45 for (uint32_t ct=0; ct < prog->getUniformCount(); ct++) {
Alex Sakhartchouked9f2102010-11-09 17:00:54 -080046 if (data[ct].slot >= 0 && data[ct].arraySize > 1) {
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -080047 //Iterate over the list of active GL uniforms and find highest array index
Alex Sakhartchouked9f2102010-11-09 17:00:54 -080048 for (uint32_t ui = 0; ui < uniListSize; ui ++) {
49 if (prog->getUniformName(ct) == uniformList[ui]->name) {
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -080050 data[ct].arraySize = (uint32_t)uniformList[ui]->arraySize;
51 break;
52 }
53 }
54 }
55
56 if (rsc->props.mLogShaders) {
Steve Block71f2cf12011-10-20 11:56:00 +010057 ALOGV("%s U, %s = %d, arraySize = %d\n", logTag,
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -080058 prog->getUniformName(ct).string(), data[ct].slot, data[ct].arraySize);
59 }
60 }
61}
62
Alex Sakhartchouk4a36b452011-04-29 16:49:08 -070063void RsdShaderCache::populateUniformData(RsdShader *prog, uint32_t linkedID, UniformData *data) {
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -080064 for (uint32_t ct=0; ct < prog->getUniformCount(); ct++) {
65 data[ct].slot = glGetUniformLocation(linkedID, prog->getUniformName(ct));
66 data[ct].arraySize = prog->getUniformArraySize(ct);
67 }
68}
69
Alex Sakhartchouk4a36b452011-04-29 16:49:08 -070070bool RsdShaderCache::hasArrayUniforms(RsdShader *vtx, RsdShader *frag) {
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -080071 UniformData *data = mCurrent->vtxUniforms;
72 for (uint32_t ct=0; ct < vtx->getUniformCount(); ct++) {
Alex Sakhartchouked9f2102010-11-09 17:00:54 -080073 if (data[ct].slot >= 0 && data[ct].arraySize > 1) {
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -080074 return true;
75 }
76 }
77 data = mCurrent->fragUniforms;
78 for (uint32_t ct=0; ct < frag->getUniformCount(); ct++) {
Alex Sakhartchouked9f2102010-11-09 17:00:54 -080079 if (data[ct].slot >= 0 && data[ct].arraySize > 1) {
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -080080 return true;
81 }
82 }
83 return false;
84}
85
Alex Sakhartchouk4a36b452011-04-29 16:49:08 -070086bool RsdShaderCache::setup(const Context *rsc) {
87 if (!mVertexDirty && !mFragmentDirty) {
88 return true;
89 }
90
91 if (!link(rsc)) {
92 return false;
93 }
94
95 if (mFragmentDirty) {
96 mFragment->setup(rsc, this);
97 mFragmentDirty = false;
98 }
99 if (mVertexDirty) {
100 mVertex->setup(rsc, this);
101 mVertexDirty = false;
102 }
103
104 return true;
105}
106
107bool RsdShaderCache::link(const Context *rsc) {
108
109 RsdShader *vtx = mVertex;
110 RsdShader *frag = mFragment;
Jason Samsbb51c402009-11-25 13:22:07 -0800111 if (!vtx->getShaderID()) {
Jason Sams5dad8b42009-12-15 19:10:11 -0800112 vtx->loadShader(rsc);
Jason Samsbb51c402009-11-25 13:22:07 -0800113 }
114 if (!frag->getShaderID()) {
Jason Sams5dad8b42009-12-15 19:10:11 -0800115 frag->loadShader(rsc);
Jason Samsbb51c402009-11-25 13:22:07 -0800116 }
Alex Sakhartchouk4378f112010-09-29 09:49:13 -0700117
118 // Don't try to cache if shaders failed to load
Alex Sakhartchouked9f2102010-11-09 17:00:54 -0800119 if (!vtx->getShaderID() || !frag->getShaderID()) {
Alex Sakhartchouk4378f112010-09-29 09:49:13 -0700120 return false;
121 }
Alex Sakhartchoukfeede2a2010-10-01 10:54:06 -0700122 uint32_t entryCount = mEntries.size();
Alex Sakhartchouked9f2102010-11-09 17:00:54 -0800123 for (uint32_t ct = 0; ct < entryCount; ct ++) {
Alex Sakhartchoukfeede2a2010-10-01 10:54:06 -0700124 if ((mEntries[ct]->vtx == vtx->getShaderID()) &&
125 (mEntries[ct]->frag == frag->getShaderID())) {
Jason Samsbb51c402009-11-25 13:22:07 -0800126
Steve Block71f2cf12011-10-20 11:56:00 +0100127 //ALOGV("SC using program %i", mEntries[ct]->program);
Alex Sakhartchoukfeede2a2010-10-01 10:54:06 -0700128 glUseProgram(mEntries[ct]->program);
129 mCurrent = mEntries[ct];
Steve Block71f2cf12011-10-20 11:56:00 +0100130 //ALOGV("RsdShaderCache hit, using %i", ct);
Alex Sakhartchouk407cae92011-05-06 14:59:45 -0700131 rsdGLCheckError(rsc, "RsdShaderCache::link (hit)");
Jason Samsbb51c402009-11-25 13:22:07 -0800132 return true;
133 }
134 }
Jason Samsbb51c402009-11-25 13:22:07 -0800135
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -0800136 ProgramEntry *e = new ProgramEntry(vtx->getAttribCount(),
137 vtx->getUniformCount(),
138 frag->getUniformCount());
Alex Sakhartchoukfeede2a2010-10-01 10:54:06 -0700139 mEntries.push(e);
Jason Samsbb51c402009-11-25 13:22:07 -0800140 mCurrent = e;
141 e->vtx = vtx->getShaderID();
142 e->frag = frag->getShaderID();
143 e->program = glCreateProgram();
Alex Sakhartchoukfeede2a2010-10-01 10:54:06 -0700144 if (e->program) {
Jason Samsbb51c402009-11-25 13:22:07 -0800145 GLuint pgm = e->program;
146 glAttachShader(pgm, vtx->getShaderID());
Steve Block3762c312012-01-06 19:20:56 +0000147 //ALOGE("e1 %x", glGetError());
Jason Samsbb51c402009-11-25 13:22:07 -0800148 glAttachShader(pgm, frag->getShaderID());
149
Alex Sakhartchouk4a36b452011-04-29 16:49:08 -0700150 glBindAttribLocation(pgm, 0, "ATTRIB_position");
151 glBindAttribLocation(pgm, 1, "ATTRIB_color");
152 glBindAttribLocation(pgm, 2, "ATTRIB_normal");
153 glBindAttribLocation(pgm, 3, "ATTRIB_texture0");
Jason Samsbb51c402009-11-25 13:22:07 -0800154
Steve Block3762c312012-01-06 19:20:56 +0000155 //ALOGE("e2 %x", glGetError());
Jason Samsbb51c402009-11-25 13:22:07 -0800156 glLinkProgram(pgm);
Steve Block3762c312012-01-06 19:20:56 +0000157 //ALOGE("e3 %x", glGetError());
Jason Samsbb51c402009-11-25 13:22:07 -0800158 GLint linkStatus = GL_FALSE;
159 glGetProgramiv(pgm, GL_LINK_STATUS, &linkStatus);
160 if (linkStatus != GL_TRUE) {
161 GLint bufLength = 0;
162 glGetProgramiv(pgm, GL_INFO_LOG_LENGTH, &bufLength);
163 if (bufLength) {
164 char* buf = (char*) malloc(bufLength);
165 if (buf) {
166 glGetProgramInfoLog(pgm, bufLength, NULL, buf);
Alex Sakhartchouk257e8a92012-02-07 18:06:13 -0800167 rsc->setError(RS_ERROR_FATAL_PROGRAM_LINK, buf);
Jason Samsbb51c402009-11-25 13:22:07 -0800168 free(buf);
169 }
170 }
171 glDeleteProgram(pgm);
Jason Sams156cce62010-03-03 13:03:18 -0800172 return false;
Jason Samsbb51c402009-11-25 13:22:07 -0800173 }
Alex Sakhartchouk4378f112010-09-29 09:49:13 -0700174
175 for (uint32_t ct=0; ct < e->vtxAttrCount; ct++) {
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -0800176 e->vtxAttrs[ct].slot = glGetAttribLocation(pgm, vtx->getAttribName(ct));
177 e->vtxAttrs[ct].name = vtx->getAttribName(ct).string();
Alex Sakhartchouk4378f112010-09-29 09:49:13 -0700178 if (rsc->props.mLogShaders) {
Steve Block71f2cf12011-10-20 11:56:00 +0100179 ALOGV("vtx A %i, %s = %d\n", ct, vtx->getAttribName(ct).string(), e->vtxAttrs[ct].slot);
Jason Sams5dad8b42009-12-15 19:10:11 -0800180 }
Jason Samsbb51c402009-11-25 13:22:07 -0800181 }
Alex Sakhartchouk4378f112010-09-29 09:49:13 -0700182
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -0800183 populateUniformData(vtx, pgm, e->vtxUniforms);
184 populateUniformData(frag, pgm, e->fragUniforms);
185
186 // Only populate this list if we have arrays in our uniforms
187 UniformQueryData **uniformList = NULL;
188 GLint numUniforms = 0;
189 bool hasArrays = hasArrayUniforms(vtx, frag);
Alex Sakhartchouked9f2102010-11-09 17:00:54 -0800190 if (hasArrays) {
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -0800191 // Get the number of active uniforms and the length of the longest name
192 glGetProgramiv(pgm, GL_ACTIVE_UNIFORMS, &numUniforms);
193 GLint maxNameLength = 0;
194 glGetProgramiv(pgm, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxNameLength);
Alex Sakhartchouked9f2102010-11-09 17:00:54 -0800195 if (numUniforms > 0 && maxNameLength > 0) {
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -0800196 uniformList = new UniformQueryData*[numUniforms];
197 // Iterate over all the uniforms and build the list we
198 // can later use to match our uniforms to
Alex Sakhartchouked9f2102010-11-09 17:00:54 -0800199 for (uint32_t ct = 0; ct < (uint32_t)numUniforms; ct++) {
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -0800200 uniformList[ct] = new UniformQueryData(maxNameLength);
201 glGetActiveUniform(pgm, ct, maxNameLength, &uniformList[ct]->writtenLength,
202 &uniformList[ct]->arraySize, &uniformList[ct]->type,
203 uniformList[ct]->name);
Steve Block3762c312012-01-06 19:20:56 +0000204 //ALOGE("GL UNI idx=%u, arraySize=%u, name=%s", ct,
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -0800205 // uniformList[ct]->arraySize, uniformList[ct]->name);
206 }
Jason Sams5dad8b42009-12-15 19:10:11 -0800207 }
Jason Samsbb51c402009-11-25 13:22:07 -0800208 }
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -0800209
210 // We now know the highest index of all of the array uniforms
211 // and we need to update our cache to reflect that
212 // we may have declared [n], but only m < n elements are used
213 updateUniformArrayData(rsc, vtx, pgm, e->vtxUniforms, "vtx",
214 uniformList, (uint32_t)numUniforms);
215 updateUniformArrayData(rsc, frag, pgm, e->fragUniforms, "frag",
216 uniformList, (uint32_t)numUniforms);
217
218 // Clean up the uniform data from GL
Alex Sakhartchouked9f2102010-11-09 17:00:54 -0800219 if (uniformList != NULL) {
220 for (uint32_t ct = 0; ct < (uint32_t)numUniforms; ct++) {
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -0800221 delete uniformList[ct];
Jason Sams5dad8b42009-12-15 19:10:11 -0800222 }
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -0800223 delete[] uniformList;
224 uniformList = NULL;
Jason Samsbb51c402009-11-25 13:22:07 -0800225 }
226 }
227
Steve Block71f2cf12011-10-20 11:56:00 +0100228 //ALOGV("SC made program %i", e->program);
Jason Samsbb51c402009-11-25 13:22:07 -0800229 glUseProgram(e->program);
Alex Sakhartchouk407cae92011-05-06 14:59:45 -0700230 rsdGLCheckError(rsc, "RsdShaderCache::link (miss)");
Alex Sakhartchouk4a36b452011-04-29 16:49:08 -0700231
Jason Samsbb51c402009-11-25 13:22:07 -0800232 return true;
233}
234
Alex Sakhartchouk4a36b452011-04-29 16:49:08 -0700235int32_t RsdShaderCache::vtxAttribSlot(const String8 &attrName) const {
Alex Sakhartchouk4378f112010-09-29 09:49:13 -0700236 for (uint32_t ct=0; ct < mCurrent->vtxAttrCount; ct++) {
Alex Sakhartchouked9f2102010-11-09 17:00:54 -0800237 if (attrName == mCurrent->vtxAttrs[ct].name) {
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -0800238 return mCurrent->vtxAttrs[ct].slot;
Alex Sakhartchouk4378f112010-09-29 09:49:13 -0700239 }
240 }
241 return -1;
242}
243
Alex Sakhartchouk4a36b452011-04-29 16:49:08 -0700244void RsdShaderCache::cleanupVertex(uint32_t id) {
Alex Sakhartchoukfeede2a2010-10-01 10:54:06 -0700245 int32_t numEntries = (int32_t)mEntries.size();
Alex Sakhartchouked9f2102010-11-09 17:00:54 -0800246 for (int32_t ct = 0; ct < numEntries; ct ++) {
Alex Sakhartchoukfeede2a2010-10-01 10:54:06 -0700247 if (mEntries[ct]->vtx == id) {
248 glDeleteProgram(mEntries[ct]->program);
249
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -0800250 delete mEntries[ct];
Alex Sakhartchoukfeede2a2010-10-01 10:54:06 -0700251 mEntries.removeAt(ct);
252 numEntries = (int32_t)mEntries.size();
253 ct --;
254 }
255 }
Jason Samsbb51c402009-11-25 13:22:07 -0800256}
257
Alex Sakhartchouk4a36b452011-04-29 16:49:08 -0700258void RsdShaderCache::cleanupFragment(uint32_t id) {
Alex Sakhartchoukfeede2a2010-10-01 10:54:06 -0700259 int32_t numEntries = (int32_t)mEntries.size();
Alex Sakhartchouked9f2102010-11-09 17:00:54 -0800260 for (int32_t ct = 0; ct < numEntries; ct ++) {
Alex Sakhartchoukfeede2a2010-10-01 10:54:06 -0700261 if (mEntries[ct]->frag == id) {
262 glDeleteProgram(mEntries[ct]->program);
263
Alex Sakhartchouk9d71e212010-11-08 15:10:52 -0800264 delete mEntries[ct];
Alex Sakhartchoukfeede2a2010-10-01 10:54:06 -0700265 mEntries.removeAt(ct);
266 numEntries = (int32_t)mEntries.size();
267 ct --;
268 }
269 }
Jason Samsbb51c402009-11-25 13:22:07 -0800270}
271
Alex Sakhartchouk4a36b452011-04-29 16:49:08 -0700272void RsdShaderCache::cleanupAll() {
Jason Sams49945c02011-01-05 03:37:48 -0800273 for (uint32_t ct=0; ct < mEntries.size(); ct++) {
274 glDeleteProgram(mEntries[ct]->program);
275 free(mEntries[ct]);
276 }
277 mEntries.clear();
Jason Samsbb51c402009-11-25 13:22:07 -0800278}
279