1 /*
2 * Copyright (C) 2010 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 <utils/JenkinsHash.h>
18
19 #include "Caches.h"
20 #include "Debug.h"
21 #include "GradientCache.h"
22 #include "Properties.h"
23
24 #include <cutils/properties.h>
25
26 namespace android {
27 namespace uirenderer {
28
29 ///////////////////////////////////////////////////////////////////////////////
30 // Functions
31 ///////////////////////////////////////////////////////////////////////////////
32
33 template<typename T>
min(T a,T b)34 static inline T min(T a, T b) {
35 return a < b ? a : b;
36 }
37
38 ///////////////////////////////////////////////////////////////////////////////
39 // Cache entry
40 ///////////////////////////////////////////////////////////////////////////////
41
hash() const42 hash_t GradientCacheEntry::hash() const {
43 uint32_t hash = JenkinsHashMix(0, count);
44 for (uint32_t i = 0; i < count; i++) {
45 hash = JenkinsHashMix(hash, android::hash_type(colors[i]));
46 hash = JenkinsHashMix(hash, android::hash_type(positions[i]));
47 }
48 return JenkinsHashWhiten(hash);
49 }
50
compare(const GradientCacheEntry & lhs,const GradientCacheEntry & rhs)51 int GradientCacheEntry::compare(const GradientCacheEntry& lhs, const GradientCacheEntry& rhs) {
52 int deltaInt = int(lhs.count) - int(rhs.count);
53 if (deltaInt != 0) return deltaInt;
54
55 deltaInt = memcmp(lhs.colors.get(), rhs.colors.get(), lhs.count * sizeof(uint32_t));
56 if (deltaInt != 0) return deltaInt;
57
58 return memcmp(lhs.positions.get(), rhs.positions.get(), lhs.count * sizeof(float));
59 }
60
61 ///////////////////////////////////////////////////////////////////////////////
62 // Constructors/destructor
63 ///////////////////////////////////////////////////////////////////////////////
64
GradientCache(Extensions & extensions)65 GradientCache::GradientCache(Extensions& extensions)
66 : mCache(LruCache<GradientCacheEntry, Texture*>::kUnlimitedCapacity)
67 , mSize(0)
68 , mMaxSize(Properties::gradientCacheSize)
69 , mUseFloatTexture(extensions.hasFloatTextures())
70 , mHasNpot(extensions.hasNPot()){
71 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
72
73 mCache.setOnEntryRemovedListener(this);
74 }
75
~GradientCache()76 GradientCache::~GradientCache() {
77 mCache.clear();
78 }
79
80 ///////////////////////////////////////////////////////////////////////////////
81 // Size management
82 ///////////////////////////////////////////////////////////////////////////////
83
getSize()84 uint32_t GradientCache::getSize() {
85 return mSize;
86 }
87
getMaxSize()88 uint32_t GradientCache::getMaxSize() {
89 return mMaxSize;
90 }
91
92 ///////////////////////////////////////////////////////////////////////////////
93 // Callbacks
94 ///////////////////////////////////////////////////////////////////////////////
95
operator ()(GradientCacheEntry &,Texture * & texture)96 void GradientCache::operator()(GradientCacheEntry&, Texture*& texture) {
97 if (texture) {
98 mSize -= texture->objectSize();
99 texture->deleteTexture();
100 delete texture;
101 }
102 }
103
104 ///////////////////////////////////////////////////////////////////////////////
105 // Caching
106 ///////////////////////////////////////////////////////////////////////////////
107
get(uint32_t * colors,float * positions,int count)108 Texture* GradientCache::get(uint32_t* colors, float* positions, int count) {
109 GradientCacheEntry gradient(colors, positions, count);
110 Texture* texture = mCache.get(gradient);
111
112 if (!texture) {
113 texture = addLinearGradient(gradient, colors, positions, count);
114 }
115
116 return texture;
117 }
118
clear()119 void GradientCache::clear() {
120 mCache.clear();
121 }
122
getGradientInfo(const uint32_t * colors,const int count,GradientInfo & info)123 void GradientCache::getGradientInfo(const uint32_t* colors, const int count,
124 GradientInfo& info) {
125 uint32_t width = 256 * (count - 1);
126
127 // If the npot extension is not supported we cannot use non-clamp
128 // wrap modes. We therefore find the nearest largest power of 2
129 // unless width is already a power of 2
130 if (!mHasNpot && (width & (width - 1)) != 0) {
131 width = 1 << (32 - __builtin_clz(width));
132 }
133
134 bool hasAlpha = false;
135 for (int i = 0; i < count; i++) {
136 if (((colors[i] >> 24) & 0xff) < 255) {
137 hasAlpha = true;
138 break;
139 }
140 }
141
142 info.width = min(width, uint32_t(mMaxTextureSize));
143 info.hasAlpha = hasAlpha;
144 }
145
addLinearGradient(GradientCacheEntry & gradient,uint32_t * colors,float * positions,int count)146 Texture* GradientCache::addLinearGradient(GradientCacheEntry& gradient,
147 uint32_t* colors, float* positions, int count) {
148
149 GradientInfo info;
150 getGradientInfo(colors, count, info);
151
152 Texture* texture = new Texture(Caches::getInstance());
153 texture->blend = info.hasAlpha;
154 texture->generation = 1;
155
156 // Assume the cache is always big enough
157 const uint32_t size = info.width * 2 * bytesPerPixel();
158 while (getSize() + size > mMaxSize) {
159 LOG_ALWAYS_FATAL_IF(!mCache.removeOldest(),
160 "Ran out of things to remove from the cache? getSize() = %" PRIu32
161 ", size = %" PRIu32 ", mMaxSize = %" PRIu32 ", width = %" PRIu32,
162 getSize(), size, mMaxSize, info.width);
163 }
164
165 generateTexture(colors, positions, info.width, 2, texture);
166
167 mSize += size;
168 LOG_ALWAYS_FATAL_IF((int)size != texture->objectSize(),
169 "size != texture->objectSize(), size %" PRIu32 ", objectSize %d"
170 " width = %" PRIu32 " bytesPerPixel() = %zu",
171 size, texture->objectSize(), info.width, bytesPerPixel());
172 mCache.put(gradient, texture);
173
174 return texture;
175 }
176
bytesPerPixel() const177 size_t GradientCache::bytesPerPixel() const {
178 // We use 4 channels (RGBA)
179 return 4 * (mUseFloatTexture ? sizeof(float) : sizeof(uint8_t));
180 }
181
splitToBytes(uint32_t inColor,GradientColor & outColor) const182 void GradientCache::splitToBytes(uint32_t inColor, GradientColor& outColor) const {
183 outColor.r = (inColor >> 16) & 0xff;
184 outColor.g = (inColor >> 8) & 0xff;
185 outColor.b = (inColor >> 0) & 0xff;
186 outColor.a = (inColor >> 24) & 0xff;
187 }
188
splitToFloats(uint32_t inColor,GradientColor & outColor) const189 void GradientCache::splitToFloats(uint32_t inColor, GradientColor& outColor) const {
190 outColor.r = ((inColor >> 16) & 0xff) / 255.0f;
191 outColor.g = ((inColor >> 8) & 0xff) / 255.0f;
192 outColor.b = ((inColor >> 0) & 0xff) / 255.0f;
193 outColor.a = ((inColor >> 24) & 0xff) / 255.0f;
194 }
195
mixBytes(GradientColor & start,GradientColor & end,float amount,uint8_t * & dst) const196 void GradientCache::mixBytes(GradientColor& start, GradientColor& end, float amount,
197 uint8_t*& dst) const {
198 float oppAmount = 1.0f - amount;
199 const float alpha = start.a * oppAmount + end.a * amount;
200 const float a = alpha / 255.0f;
201
202 *dst++ = uint8_t(a * (start.r * oppAmount + end.r * amount));
203 *dst++ = uint8_t(a * (start.g * oppAmount + end.g * amount));
204 *dst++ = uint8_t(a * (start.b * oppAmount + end.b * amount));
205 *dst++ = uint8_t(alpha);
206 }
207
mixFloats(GradientColor & start,GradientColor & end,float amount,uint8_t * & dst) const208 void GradientCache::mixFloats(GradientColor& start, GradientColor& end, float amount,
209 uint8_t*& dst) const {
210 float oppAmount = 1.0f - amount;
211 const float a = start.a * oppAmount + end.a * amount;
212
213 float* d = (float*) dst;
214 *d++ = a * (start.r * oppAmount + end.r * amount);
215 *d++ = a * (start.g * oppAmount + end.g * amount);
216 *d++ = a * (start.b * oppAmount + end.b * amount);
217 *d++ = a;
218
219 dst += 4 * sizeof(float);
220 }
221
generateTexture(uint32_t * colors,float * positions,const uint32_t width,const uint32_t height,Texture * texture)222 void GradientCache::generateTexture(uint32_t* colors, float* positions,
223 const uint32_t width, const uint32_t height, Texture* texture) {
224 const GLsizei rowBytes = width * bytesPerPixel();
225 uint8_t pixels[rowBytes * height];
226
227 static ChannelSplitter gSplitters[] = {
228 &android::uirenderer::GradientCache::splitToBytes,
229 &android::uirenderer::GradientCache::splitToFloats,
230 };
231 ChannelSplitter split = gSplitters[mUseFloatTexture];
232
233 static ChannelMixer gMixers[] = {
234 &android::uirenderer::GradientCache::mixBytes,
235 &android::uirenderer::GradientCache::mixFloats,
236 };
237 ChannelMixer mix = gMixers[mUseFloatTexture];
238
239 GradientColor start;
240 (this->*split)(colors[0], start);
241
242 GradientColor end;
243 (this->*split)(colors[1], end);
244
245 int currentPos = 1;
246 float startPos = positions[0];
247 float distance = positions[1] - startPos;
248
249 uint8_t* dst = pixels;
250 for (uint32_t x = 0; x < width; x++) {
251 float pos = x / float(width - 1);
252 if (pos > positions[currentPos]) {
253 start = end;
254 startPos = positions[currentPos];
255
256 currentPos++;
257
258 (this->*split)(colors[currentPos], end);
259 distance = positions[currentPos] - startPos;
260 }
261
262 float amount = (pos - startPos) / distance;
263 (this->*mix)(start, end, amount, dst);
264 }
265
266 memcpy(pixels + rowBytes, pixels, rowBytes);
267
268 if (mUseFloatTexture) {
269 // We have to use GL_RGBA16F because GL_RGBA32F does not support filtering
270 texture->upload(GL_RGBA16F, width, height, GL_RGBA, GL_FLOAT, pixels);
271 } else {
272 texture->upload(GL_RGBA, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
273 }
274
275 texture->setFilter(GL_LINEAR);
276 texture->setWrap(GL_CLAMP_TO_EDGE);
277 }
278
279 }; // namespace uirenderer
280 }; // namespace android
281