GradientCache.cpp revision 8e93a7c9377b4ae43ecfb408f4906a09f6c83c03
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#define LOG_TAG "OpenGLRenderer" 18 19#include <utils/JenkinsHash.h> 20 21#include "Caches.h" 22#include "Debug.h" 23#include "GradientCache.h" 24#include "Properties.h" 25 26namespace android { 27namespace uirenderer { 28 29/////////////////////////////////////////////////////////////////////////////// 30// Functions 31/////////////////////////////////////////////////////////////////////////////// 32 33template<typename T> 34static inline T min(T a, T b) { 35 return a < b ? a : b; 36} 37 38/////////////////////////////////////////////////////////////////////////////// 39// Cache entry 40/////////////////////////////////////////////////////////////////////////////// 41 42hash_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 51int 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 65GradientCache::GradientCache(Extensions& extensions) 66 : mCache(LruCache<GradientCacheEntry, Texture*>::kUnlimitedCapacity) 67 , mSize(0) 68 , mMaxSize(MB(DEFAULT_GRADIENT_CACHE_SIZE)) 69 , mUseFloatTexture(extensions.hasFloatTextures()) 70 , mHasNpot(extensions.hasNPot()){ 71 char property[PROPERTY_VALUE_MAX]; 72 if (property_get(PROPERTY_GRADIENT_CACHE_SIZE, property, nullptr) > 0) { 73 INIT_LOGD(" Setting gradient cache size to %sMB", property); 74 setMaxSize(MB(atof(property))); 75 } else { 76 INIT_LOGD(" Using default gradient cache size of %.2fMB", DEFAULT_GRADIENT_CACHE_SIZE); 77 } 78 79 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize); 80 81 mCache.setOnEntryRemovedListener(this); 82} 83 84GradientCache::~GradientCache() { 85 mCache.clear(); 86} 87 88/////////////////////////////////////////////////////////////////////////////// 89// Size management 90/////////////////////////////////////////////////////////////////////////////// 91 92uint32_t GradientCache::getSize() { 93 return mSize; 94} 95 96uint32_t GradientCache::getMaxSize() { 97 return mMaxSize; 98} 99 100void GradientCache::setMaxSize(uint32_t maxSize) { 101 mMaxSize = maxSize; 102 while (mSize > mMaxSize) { 103 mCache.removeOldest(); 104 } 105} 106 107/////////////////////////////////////////////////////////////////////////////// 108// Callbacks 109/////////////////////////////////////////////////////////////////////////////// 110 111void GradientCache::operator()(GradientCacheEntry&, Texture*& texture) { 112 if (texture) { 113 const uint32_t size = texture->width * texture->height * bytesPerPixel(); 114 mSize -= size; 115 116 texture->deleteTexture(); 117 delete texture; 118 } 119} 120 121/////////////////////////////////////////////////////////////////////////////// 122// Caching 123/////////////////////////////////////////////////////////////////////////////// 124 125Texture* GradientCache::get(uint32_t* colors, float* positions, int count) { 126 GradientCacheEntry gradient(colors, positions, count); 127 Texture* texture = mCache.get(gradient); 128 129 if (!texture) { 130 texture = addLinearGradient(gradient, colors, positions, count); 131 } 132 133 return texture; 134} 135 136void GradientCache::clear() { 137 mCache.clear(); 138} 139 140void GradientCache::getGradientInfo(const uint32_t* colors, const int count, 141 GradientInfo& info) { 142 uint32_t width = 256 * (count - 1); 143 144 // If the npot extension is not supported we cannot use non-clamp 145 // wrap modes. We therefore find the nearest largest power of 2 146 // unless width is already a power of 2 147 if (!mHasNpot && (width & (width - 1)) != 0) { 148 width = 1 << (32 - __builtin_clz(width)); 149 } 150 151 bool hasAlpha = false; 152 for (int i = 0; i < count; i++) { 153 if (((colors[i] >> 24) & 0xff) < 255) { 154 hasAlpha = true; 155 break; 156 } 157 } 158 159 info.width = min(width, uint32_t(mMaxTextureSize)); 160 info.hasAlpha = hasAlpha; 161} 162 163Texture* GradientCache::addLinearGradient(GradientCacheEntry& gradient, 164 uint32_t* colors, float* positions, int count) { 165 166 GradientInfo info; 167 getGradientInfo(colors, count, info); 168 169 Texture* texture = new Texture(Caches::getInstance()); 170 texture->width = info.width; 171 texture->height = 2; 172 texture->blend = info.hasAlpha; 173 texture->generation = 1; 174 175 // Asume the cache is always big enough 176 const uint32_t size = texture->width * texture->height * bytesPerPixel(); 177 while (getSize() + size > mMaxSize) { 178 mCache.removeOldest(); 179 } 180 181 generateTexture(colors, positions, texture); 182 183 mSize += size; 184 mCache.put(gradient, texture); 185 186 return texture; 187} 188 189size_t GradientCache::bytesPerPixel() const { 190 // We use 4 channels (RGBA) 191 return 4 * (mUseFloatTexture ? sizeof(float) : sizeof(uint8_t)); 192} 193 194void GradientCache::splitToBytes(uint32_t inColor, GradientColor& outColor) const { 195 outColor.r = (inColor >> 16) & 0xff; 196 outColor.g = (inColor >> 8) & 0xff; 197 outColor.b = (inColor >> 0) & 0xff; 198 outColor.a = (inColor >> 24) & 0xff; 199} 200 201void GradientCache::splitToFloats(uint32_t inColor, GradientColor& outColor) const { 202 outColor.r = ((inColor >> 16) & 0xff) / 255.0f; 203 outColor.g = ((inColor >> 8) & 0xff) / 255.0f; 204 outColor.b = ((inColor >> 0) & 0xff) / 255.0f; 205 outColor.a = ((inColor >> 24) & 0xff) / 255.0f; 206} 207 208void GradientCache::mixBytes(GradientColor& start, GradientColor& end, float amount, 209 uint8_t*& dst) const { 210 float oppAmount = 1.0f - amount; 211 const float alpha = start.a * oppAmount + end.a * amount; 212 const float a = alpha / 255.0f; 213 214 *dst++ = uint8_t(a * (start.r * oppAmount + end.r * amount)); 215 *dst++ = uint8_t(a * (start.g * oppAmount + end.g * amount)); 216 *dst++ = uint8_t(a * (start.b * oppAmount + end.b * amount)); 217 *dst++ = uint8_t(alpha); 218} 219 220void GradientCache::mixFloats(GradientColor& start, GradientColor& end, float amount, 221 uint8_t*& dst) const { 222 float oppAmount = 1.0f - amount; 223 const float a = start.a * oppAmount + end.a * amount; 224 225 float* d = (float*) dst; 226 *d++ = a * (start.r * oppAmount + end.r * amount); 227 *d++ = a * (start.g * oppAmount + end.g * amount); 228 *d++ = a * (start.b * oppAmount + end.b * amount); 229 *d++ = a; 230 231 dst += 4 * sizeof(float); 232} 233 234void GradientCache::generateTexture(uint32_t* colors, float* positions, Texture* texture) { 235 const uint32_t width = texture->width; 236 const GLsizei rowBytes = width * bytesPerPixel(); 237 uint8_t pixels[rowBytes * texture->height]; 238 239 static ChannelSplitter gSplitters[] = { 240 &android::uirenderer::GradientCache::splitToBytes, 241 &android::uirenderer::GradientCache::splitToFloats, 242 }; 243 ChannelSplitter split = gSplitters[mUseFloatTexture]; 244 245 static ChannelMixer gMixers[] = { 246 &android::uirenderer::GradientCache::mixBytes, 247 &android::uirenderer::GradientCache::mixFloats, 248 }; 249 ChannelMixer mix = gMixers[mUseFloatTexture]; 250 251 GradientColor start; 252 (this->*split)(colors[0], start); 253 254 GradientColor end; 255 (this->*split)(colors[1], end); 256 257 int currentPos = 1; 258 float startPos = positions[0]; 259 float distance = positions[1] - startPos; 260 261 uint8_t* dst = pixels; 262 for (uint32_t x = 0; x < width; x++) { 263 float pos = x / float(width - 1); 264 if (pos > positions[currentPos]) { 265 start = end; 266 startPos = positions[currentPos]; 267 268 currentPos++; 269 270 (this->*split)(colors[currentPos], end); 271 distance = positions[currentPos] - startPos; 272 } 273 274 float amount = (pos - startPos) / distance; 275 (this->*mix)(start, end, amount, dst); 276 } 277 278 memcpy(pixels + rowBytes, pixels, rowBytes); 279 280 glGenTextures(1, &texture->id); 281 Caches::getInstance().textureState().bindTexture(texture->id); 282 glPixelStorei(GL_UNPACK_ALIGNMENT, 4); 283 284 if (mUseFloatTexture) { 285 // We have to use GL_RGBA16F because GL_RGBA32F does not support filtering 286 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, width, texture->height, 0, 287 GL_RGBA, GL_FLOAT, pixels); 288 } else { 289 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, texture->height, 0, 290 GL_RGBA, GL_UNSIGNED_BYTE, pixels); 291 } 292 293 texture->setFilter(GL_LINEAR); 294 texture->setWrap(GL_CLAMP_TO_EDGE); 295} 296 297}; // namespace uirenderer 298}; // namespace android 299