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 <GLES2/gl2.h> 20 21 #include <SkCanvas.h> 22 23 #include <utils/threads.h> 24 25 #include "TextureCache.h" 26 #include "Properties.h" 27 28 namespace android { 29 namespace uirenderer { 30 31 /////////////////////////////////////////////////////////////////////////////// 32 // Constructors/destructor 33 /////////////////////////////////////////////////////////////////////////////// 34 35 TextureCache::TextureCache(): 36 mCache(GenerationCache<SkBitmap*, Texture*>::kUnlimitedCapacity), 37 mSize(0), mMaxSize(MB(DEFAULT_TEXTURE_CACHE_SIZE)), 38 mFlushRate(DEFAULT_TEXTURE_CACHE_FLUSH_RATE) { 39 char property[PROPERTY_VALUE_MAX]; 40 if (property_get(PROPERTY_TEXTURE_CACHE_SIZE, property, NULL) > 0) { 41 INIT_LOGD(" Setting texture cache size to %sMB", property); 42 setMaxSize(MB(atof(property))); 43 } else { 44 INIT_LOGD(" Using default texture cache size of %.2fMB", DEFAULT_TEXTURE_CACHE_SIZE); 45 } 46 47 if (property_get(PROPERTY_TEXTURE_CACHE_FLUSH_RATE, property, NULL) > 0) { 48 float flushRate = atof(property); 49 INIT_LOGD(" Setting texture cache flush rate to %.2f%%", flushRate * 100.0f); 50 setFlushRate(flushRate); 51 } else { 52 INIT_LOGD(" Using default texture cache flush rate of %.2f%%", 53 DEFAULT_TEXTURE_CACHE_FLUSH_RATE * 100.0f); 54 } 55 56 init(); 57 } 58 59 TextureCache::TextureCache(uint32_t maxByteSize): 60 mCache(GenerationCache<SkBitmap*, Texture*>::kUnlimitedCapacity), 61 mSize(0), mMaxSize(maxByteSize) { 62 init(); 63 } 64 65 TextureCache::~TextureCache() { 66 mCache.clear(); 67 } 68 69 void TextureCache::init() { 70 mCache.setOnEntryRemovedListener(this); 71 72 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize); 73 INIT_LOGD(" Maximum texture dimension is %d pixels", mMaxTextureSize); 74 75 mDebugEnabled = readDebugLevel() & kDebugCaches; 76 } 77 78 /////////////////////////////////////////////////////////////////////////////// 79 // Size management 80 /////////////////////////////////////////////////////////////////////////////// 81 82 uint32_t TextureCache::getSize() { 83 return mSize; 84 } 85 86 uint32_t TextureCache::getMaxSize() { 87 return mMaxSize; 88 } 89 90 void TextureCache::setMaxSize(uint32_t maxSize) { 91 mMaxSize = maxSize; 92 while (mSize > mMaxSize) { 93 mCache.removeOldest(); 94 } 95 } 96 97 void TextureCache::setFlushRate(float flushRate) { 98 mFlushRate = fmaxf(0.0f, fminf(1.0f, flushRate)); 99 } 100 101 /////////////////////////////////////////////////////////////////////////////// 102 // Callbacks 103 /////////////////////////////////////////////////////////////////////////////// 104 105 void TextureCache::operator()(SkBitmap*& bitmap, Texture*& texture) { 106 // This will be called already locked 107 if (texture) { 108 mSize -= texture->bitmapSize; 109 TEXTURE_LOGD("TextureCache::callback: name, removed size, mSize = %d, %d, %d", 110 texture->id, texture->bitmapSize, mSize); 111 if (mDebugEnabled) { 112 LOGD("Texture deleted, size = %d", texture->bitmapSize); 113 } 114 glDeleteTextures(1, &texture->id); 115 delete texture; 116 } 117 } 118 119 /////////////////////////////////////////////////////////////////////////////// 120 // Caching 121 /////////////////////////////////////////////////////////////////////////////// 122 123 Texture* TextureCache::get(SkBitmap* bitmap) { 124 Texture* texture = mCache.get(bitmap); 125 126 if (!texture) { 127 if (bitmap->width() > mMaxTextureSize || bitmap->height() > mMaxTextureSize) { 128 LOGW("Bitmap too large to be uploaded into a texture"); 129 return NULL; 130 } 131 132 const uint32_t size = bitmap->rowBytes() * bitmap->height(); 133 // Don't even try to cache a bitmap that's bigger than the cache 134 if (size < mMaxSize) { 135 while (mSize + size > mMaxSize) { 136 mCache.removeOldest(); 137 } 138 } 139 140 texture = new Texture; 141 texture->bitmapSize = size; 142 generateTexture(bitmap, texture, false); 143 144 if (size < mMaxSize) { 145 mSize += size; 146 TEXTURE_LOGD("TextureCache::get: create texture(%p): name, size, mSize = %d, %d, %d", 147 bitmap, texture->id, size, mSize); 148 if (mDebugEnabled) { 149 LOGD("Texture created, size = %d", size); 150 } 151 mCache.put(bitmap, texture); 152 } else { 153 texture->cleanup = true; 154 } 155 } else if (bitmap->getGenerationID() != texture->generation) { 156 generateTexture(bitmap, texture, true); 157 } 158 159 return texture; 160 } 161 162 void TextureCache::remove(SkBitmap* bitmap) { 163 mCache.remove(bitmap); 164 } 165 166 void TextureCache::removeDeferred(SkBitmap* bitmap) { 167 Mutex::Autolock _l(mLock); 168 mGarbage.push(bitmap); 169 } 170 171 void TextureCache::clearGarbage() { 172 Mutex::Autolock _l(mLock); 173 size_t count = mGarbage.size(); 174 for (size_t i = 0; i < count; i++) { 175 mCache.remove(mGarbage.itemAt(i)); 176 } 177 mGarbage.clear(); 178 } 179 180 void TextureCache::clear() { 181 mCache.clear(); 182 TEXTURE_LOGD("TextureCache:clear(), mSize = %d", mSize); 183 } 184 185 void TextureCache::flush() { 186 if (mFlushRate >= 1.0f || mCache.size() == 0) return; 187 if (mFlushRate <= 0.0f) { 188 clear(); 189 return; 190 } 191 192 uint32_t targetSize = uint32_t(mSize * mFlushRate); 193 TEXTURE_LOGD("TextureCache::flush: target size: %d", targetSize); 194 195 while (mSize > targetSize) { 196 mCache.removeOldest(); 197 } 198 } 199 200 void TextureCache::generateTexture(SkBitmap* bitmap, Texture* texture, bool regenerate) { 201 SkAutoLockPixels alp(*bitmap); 202 203 if (!bitmap->readyToDraw()) { 204 LOGE("Cannot generate texture from bitmap"); 205 return; 206 } 207 208 const bool resize = !regenerate || bitmap->width() != int(texture->width) || 209 bitmap->height() != int(texture->height); 210 211 if (!regenerate) { 212 glGenTextures(1, &texture->id); 213 } 214 215 texture->generation = bitmap->getGenerationID(); 216 texture->width = bitmap->width(); 217 texture->height = bitmap->height(); 218 219 glBindTexture(GL_TEXTURE_2D, texture->id); 220 glPixelStorei(GL_UNPACK_ALIGNMENT, bitmap->bytesPerPixel()); 221 222 switch (bitmap->getConfig()) { 223 case SkBitmap::kA8_Config: 224 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 225 uploadToTexture(resize, GL_ALPHA, bitmap->rowBytesAsPixels(), texture->height, 226 GL_UNSIGNED_BYTE, bitmap->getPixels()); 227 texture->blend = true; 228 break; 229 case SkBitmap::kRGB_565_Config: 230 uploadToTexture(resize, GL_RGB, bitmap->rowBytesAsPixels(), texture->height, 231 GL_UNSIGNED_SHORT_5_6_5, bitmap->getPixels()); 232 texture->blend = false; 233 break; 234 case SkBitmap::kARGB_8888_Config: 235 uploadToTexture(resize, GL_RGBA, bitmap->rowBytesAsPixels(), texture->height, 236 GL_UNSIGNED_BYTE, bitmap->getPixels()); 237 // Do this after calling getPixels() to make sure Skia's deferred 238 // decoding happened 239 texture->blend = !bitmap->isOpaque(); 240 break; 241 case SkBitmap::kARGB_4444_Config: 242 case SkBitmap::kIndex8_Config: 243 uploadLoFiTexture(resize, bitmap, texture->width, texture->height); 244 texture->blend = !bitmap->isOpaque(); 245 break; 246 default: 247 LOGW("Unsupported bitmap config: %d", bitmap->getConfig()); 248 break; 249 } 250 251 texture->setFilter(GL_LINEAR, GL_LINEAR); 252 texture->setWrap(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE); 253 } 254 255 void TextureCache::uploadLoFiTexture(bool resize, SkBitmap* bitmap, 256 uint32_t width, uint32_t height) { 257 SkBitmap rgbaBitmap; 258 rgbaBitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height); 259 rgbaBitmap.allocPixels(); 260 rgbaBitmap.eraseColor(0); 261 rgbaBitmap.setIsOpaque(bitmap->isOpaque()); 262 263 SkCanvas canvas(rgbaBitmap); 264 canvas.drawBitmap(*bitmap, 0.0f, 0.0f, NULL); 265 266 uploadToTexture(resize, GL_RGBA, rgbaBitmap.rowBytesAsPixels(), height, 267 GL_UNSIGNED_BYTE, rgbaBitmap.getPixels()); 268 } 269 270 void TextureCache::uploadToTexture(bool resize, GLenum format, GLsizei width, GLsizei height, 271 GLenum type, const GLvoid * data) { 272 if (resize) { 273 glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, type, data); 274 } else { 275 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, format, type, data); 276 } 277 } 278 279 }; // namespace uirenderer 280 }; // namespace android 281