1 /*
2 * Copyright 2013 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 <GLES2/gl2.h>
18 #include <GLES2/gl2ext.h>
19
20 #include <utils/String8.h>
21
22 #include "ProgramCache.h"
23 #include "Program.h"
24 #include "Description.h"
25
26 namespace android {
27 // -----------------------------------------------------------------------------------------------
28
29
30 /*
31 * A simple formatter class to automatically add the endl and
32 * manage the indentation.
33 */
34
35 class Formatter;
36 static Formatter& indent(Formatter& f);
37 static Formatter& dedent(Formatter& f);
38
39 class Formatter {
40 String8 mString;
41 int mIndent;
42 typedef Formatter& (*FormaterManipFunc)(Formatter&);
43 friend Formatter& indent(Formatter& f);
44 friend Formatter& dedent(Formatter& f);
45 public:
Formatter()46 Formatter() : mIndent(0) {}
47
getString() const48 String8 getString() const {
49 return mString;
50 }
51
operator <<(Formatter & out,const char * in)52 friend Formatter& operator << (Formatter& out, const char* in) {
53 for (int i=0 ; i<out.mIndent ; i++) {
54 out.mString.append(" ");
55 }
56 out.mString.append(in);
57 out.mString.append("\n");
58 return out;
59 }
operator <<(Formatter & out,const String8 & in)60 friend inline Formatter& operator << (Formatter& out, const String8& in) {
61 return operator << (out, in.string());
62 }
operator <<(Formatter & to,FormaterManipFunc func)63 friend inline Formatter& operator<<(Formatter& to, FormaterManipFunc func) {
64 return (*func)(to);
65 }
66 };
indent(Formatter & f)67 Formatter& indent(Formatter& f) {
68 f.mIndent++;
69 return f;
70 }
dedent(Formatter & f)71 Formatter& dedent(Formatter& f) {
72 f.mIndent--;
73 return f;
74 }
75
76 // -----------------------------------------------------------------------------------------------
77
ANDROID_SINGLETON_STATIC_INSTANCE(ProgramCache)78 ANDROID_SINGLETON_STATIC_INSTANCE(ProgramCache)
79
80 ProgramCache::ProgramCache() {
81 // Until surfaceflinger has a dependable blob cache on the filesystem,
82 // generate shaders on initialization so as to avoid jank.
83 primeCache();
84 }
85
~ProgramCache()86 ProgramCache::~ProgramCache() {
87 }
88
primeCache()89 void ProgramCache::primeCache() {
90 uint32_t shaderCount = 0;
91 uint32_t keyMask = Key::BLEND_MASK | Key::OPACITY_MASK |
92 Key::PLANE_ALPHA_MASK | Key::TEXTURE_MASK;
93 // Prime the cache for all combinations of the above masks,
94 // leaving off the experimental color matrix mask options.
95
96 nsecs_t timeBefore = systemTime();
97 for (uint32_t keyVal = 0; keyVal <= keyMask; keyVal++) {
98 Key shaderKey;
99 shaderKey.set(keyMask, keyVal);
100 uint32_t tex = shaderKey.getTextureTarget();
101 if (tex != Key::TEXTURE_OFF &&
102 tex != Key::TEXTURE_EXT &&
103 tex != Key::TEXTURE_2D) {
104 continue;
105 }
106 Program* program = mCache.valueFor(shaderKey);
107 if (program == NULL) {
108 program = generateProgram(shaderKey);
109 mCache.add(shaderKey, program);
110 shaderCount++;
111 }
112 }
113 nsecs_t timeAfter = systemTime();
114 float compileTimeMs = static_cast<float>(timeAfter - timeBefore) / 1.0E6;
115 ALOGD("shader cache generated - %u shaders in %f ms\n", shaderCount, compileTimeMs);
116 }
117
computeKey(const Description & description)118 ProgramCache::Key ProgramCache::computeKey(const Description& description) {
119 Key needs;
120 needs.set(Key::TEXTURE_MASK,
121 !description.mTextureEnabled ? Key::TEXTURE_OFF :
122 description.mTexture.getTextureTarget() == GL_TEXTURE_EXTERNAL_OES ? Key::TEXTURE_EXT :
123 description.mTexture.getTextureTarget() == GL_TEXTURE_2D ? Key::TEXTURE_2D :
124 Key::TEXTURE_OFF)
125 .set(Key::PLANE_ALPHA_MASK,
126 (description.mPlaneAlpha < 1) ? Key::PLANE_ALPHA_LT_ONE : Key::PLANE_ALPHA_EQ_ONE)
127 .set(Key::BLEND_MASK,
128 description.mPremultipliedAlpha ? Key::BLEND_PREMULT : Key::BLEND_NORMAL)
129 .set(Key::OPACITY_MASK,
130 description.mOpaque ? Key::OPACITY_OPAQUE : Key::OPACITY_TRANSLUCENT)
131 .set(Key::COLOR_MATRIX_MASK,
132 description.mColorMatrixEnabled ? Key::COLOR_MATRIX_ON : Key::COLOR_MATRIX_OFF);
133 return needs;
134 }
135
generateVertexShader(const Key & needs)136 String8 ProgramCache::generateVertexShader(const Key& needs) {
137 Formatter vs;
138 if (needs.isTexturing()) {
139 vs << "attribute vec4 texCoords;"
140 << "varying vec2 outTexCoords;";
141 }
142 vs << "attribute vec4 position;"
143 << "uniform mat4 projection;"
144 << "uniform mat4 texture;"
145 << "void main(void) {" << indent
146 << "gl_Position = projection * position;";
147 if (needs.isTexturing()) {
148 vs << "outTexCoords = (texture * texCoords).st;";
149 }
150 vs << dedent << "}";
151 return vs.getString();
152 }
153
generateFragmentShader(const Key & needs)154 String8 ProgramCache::generateFragmentShader(const Key& needs) {
155 Formatter fs;
156 if (needs.getTextureTarget() == Key::TEXTURE_EXT) {
157 fs << "#extension GL_OES_EGL_image_external : require";
158 }
159
160 // default precision is required-ish in fragment shaders
161 fs << "precision mediump float;";
162
163 if (needs.getTextureTarget() == Key::TEXTURE_EXT) {
164 fs << "uniform samplerExternalOES sampler;"
165 << "varying vec2 outTexCoords;";
166 } else if (needs.getTextureTarget() == Key::TEXTURE_2D) {
167 fs << "uniform sampler2D sampler;"
168 << "varying vec2 outTexCoords;";
169 } else if (needs.getTextureTarget() == Key::TEXTURE_OFF) {
170 fs << "uniform vec4 color;";
171 }
172 if (needs.hasPlaneAlpha()) {
173 fs << "uniform float alphaPlane;";
174 }
175 if (needs.hasColorMatrix()) {
176 fs << "uniform mat4 colorMatrix;";
177 }
178 fs << "void main(void) {" << indent;
179 if (needs.isTexturing()) {
180 fs << "gl_FragColor = texture2D(sampler, outTexCoords);";
181 } else {
182 fs << "gl_FragColor = color;";
183 }
184 if (needs.isOpaque()) {
185 fs << "gl_FragColor.a = 1.0;";
186 }
187 if (needs.hasPlaneAlpha()) {
188 // modulate the alpha value with planeAlpha
189 if (needs.isPremultiplied()) {
190 // ... and the color too if we're premultiplied
191 fs << "gl_FragColor *= alphaPlane;";
192 } else {
193 fs << "gl_FragColor.a *= alphaPlane;";
194 }
195 }
196
197 if (needs.hasColorMatrix()) {
198 if (!needs.isOpaque() && needs.isPremultiplied()) {
199 // un-premultiply if needed before linearization
200 fs << "gl_FragColor.rgb = gl_FragColor.rgb/gl_FragColor.a;";
201 }
202 fs << "vec4 transformed = colorMatrix * vec4(gl_FragColor.rgb, 1);";
203 fs << "gl_FragColor.rgb = transformed.rgb/transformed.a;";
204 if (!needs.isOpaque() && needs.isPremultiplied()) {
205 // and re-premultiply if needed after gamma correction
206 fs << "gl_FragColor.rgb = gl_FragColor.rgb*gl_FragColor.a;";
207 }
208 }
209
210 fs << dedent << "}";
211 return fs.getString();
212 }
213
generateProgram(const Key & needs)214 Program* ProgramCache::generateProgram(const Key& needs) {
215 // vertex shader
216 String8 vs = generateVertexShader(needs);
217
218 // fragment shader
219 String8 fs = generateFragmentShader(needs);
220
221 Program* program = new Program(needs, vs.string(), fs.string());
222 return program;
223 }
224
useProgram(const Description & description)225 void ProgramCache::useProgram(const Description& description) {
226
227 // generate the key for the shader based on the description
228 Key needs(computeKey(description));
229
230 // look-up the program in the cache
231 Program* program = mCache.valueFor(needs);
232 if (program == NULL) {
233 // we didn't find our program, so generate one...
234 nsecs_t time = -systemTime();
235 program = generateProgram(needs);
236 mCache.add(needs, program);
237 time += systemTime();
238
239 //ALOGD(">>> generated new program: needs=%08X, time=%u ms (%d programs)",
240 // needs.mNeeds, uint32_t(ns2ms(time)), mCache.size());
241 }
242
243 // here we have a suitable program for this description
244 if (program->isValid()) {
245 program->use();
246 program->setUniforms(description);
247 }
248 }
249
250
251 } /* namespace android */
252