TextureCache.cpp revision d43b22da291fd08017fac627561091a633c85807
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 28namespace android { 29namespace uirenderer { 30 31/////////////////////////////////////////////////////////////////////////////// 32// Constructors/destructor 33/////////////////////////////////////////////////////////////////////////////// 34 35TextureCache::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 59TextureCache::TextureCache(uint32_t maxByteSize): 60 mCache(GenerationCache<SkBitmap*, Texture*>::kUnlimitedCapacity), 61 mSize(0), mMaxSize(maxByteSize) { 62 init(); 63} 64 65TextureCache::~TextureCache() { 66 mCache.clear(); 67} 68 69void 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 82uint32_t TextureCache::getSize() { 83 return mSize; 84} 85 86uint32_t TextureCache::getMaxSize() { 87 return mMaxSize; 88} 89 90void TextureCache::setMaxSize(uint32_t maxSize) { 91 mMaxSize = maxSize; 92 while (mSize > mMaxSize) { 93 mCache.removeOldest(); 94 } 95} 96 97void TextureCache::setFlushRate(float flushRate) { 98 mFlushRate = fmaxf(0.0f, fminf(1.0f, flushRate)); 99} 100 101/////////////////////////////////////////////////////////////////////////////// 102// Callbacks 103/////////////////////////////////////////////////////////////////////////////// 104 105void 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 ALOGD("Texture deleted, size = %d", texture->bitmapSize); 113 } 114 glDeleteTextures(1, &texture->id); 115 delete texture; 116 } 117} 118 119/////////////////////////////////////////////////////////////////////////////// 120// Caching 121/////////////////////////////////////////////////////////////////////////////// 122 123Texture* TextureCache::get(SkBitmap* bitmap) { 124 Texture* texture = mCache.get(bitmap); 125 126 if (!texture) { 127 if (bitmap->width() > mMaxTextureSize || bitmap->height() > mMaxTextureSize) { 128 ALOGW("Bitmap too large to be uploaded into a texture (%dx%d, max=%dx%d)", 129 bitmap->width(), bitmap->height(), mMaxTextureSize, mMaxTextureSize); 130 return NULL; 131 } 132 133 const uint32_t size = bitmap->rowBytes() * bitmap->height(); 134 // Don't even try to cache a bitmap that's bigger than the cache 135 if (size < mMaxSize) { 136 while (mSize + size > mMaxSize) { 137 mCache.removeOldest(); 138 } 139 } 140 141 texture = new Texture; 142 texture->bitmapSize = size; 143 generateTexture(bitmap, texture, false); 144 145 if (size < mMaxSize) { 146 mSize += size; 147 TEXTURE_LOGD("TextureCache::get: create texture(%p): name, size, mSize = %d, %d, %d", 148 bitmap, texture->id, size, mSize); 149 if (mDebugEnabled) { 150 ALOGD("Texture created, size = %d", size); 151 } 152 mCache.put(bitmap, texture); 153 } else { 154 texture->cleanup = true; 155 } 156 } else if (bitmap->getGenerationID() != texture->generation) { 157 generateTexture(bitmap, texture, true); 158 } 159 160 return texture; 161} 162 163Texture* TextureCache::getTransient(SkBitmap* bitmap) { 164 Texture* texture = new Texture; 165 texture->bitmapSize = bitmap->rowBytes() * bitmap->height(); 166 texture->cleanup = true; 167 168 generateTexture(bitmap, texture, false); 169 170 return texture; 171} 172 173void TextureCache::remove(SkBitmap* bitmap) { 174 mCache.remove(bitmap); 175} 176 177void TextureCache::removeDeferred(SkBitmap* bitmap) { 178 Mutex::Autolock _l(mLock); 179 mGarbage.push(bitmap); 180} 181 182void TextureCache::clearGarbage() { 183 Mutex::Autolock _l(mLock); 184 size_t count = mGarbage.size(); 185 for (size_t i = 0; i < count; i++) { 186 mCache.remove(mGarbage.itemAt(i)); 187 } 188 mGarbage.clear(); 189} 190 191void TextureCache::clear() { 192 mCache.clear(); 193 TEXTURE_LOGD("TextureCache:clear(), mSize = %d", mSize); 194} 195 196void TextureCache::flush() { 197 if (mFlushRate >= 1.0f || mCache.size() == 0) return; 198 if (mFlushRate <= 0.0f) { 199 clear(); 200 return; 201 } 202 203 uint32_t targetSize = uint32_t(mSize * mFlushRate); 204 TEXTURE_LOGD("TextureCache::flush: target size: %d", targetSize); 205 206 while (mSize > targetSize) { 207 mCache.removeOldest(); 208 } 209} 210 211void TextureCache::generateTexture(SkBitmap* bitmap, Texture* texture, bool regenerate) { 212 SkAutoLockPixels alp(*bitmap); 213 214 if (!bitmap->readyToDraw()) { 215 ALOGE("Cannot generate texture from bitmap"); 216 return; 217 } 218 219 const bool resize = !regenerate || bitmap->width() != int(texture->width) || 220 bitmap->height() != int(texture->height); 221 222 if (!regenerate) { 223 glGenTextures(1, &texture->id); 224 } 225 226 texture->generation = bitmap->getGenerationID(); 227 texture->width = bitmap->width(); 228 texture->height = bitmap->height(); 229 230 glBindTexture(GL_TEXTURE_2D, texture->id); 231 232 switch (bitmap->getConfig()) { 233 case SkBitmap::kA8_Config: 234 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 235 uploadToTexture(resize, GL_ALPHA, bitmap->rowBytesAsPixels(), texture->height, 236 GL_UNSIGNED_BYTE, bitmap->getPixels()); 237 texture->blend = true; 238 break; 239 case SkBitmap::kRGB_565_Config: 240 glPixelStorei(GL_UNPACK_ALIGNMENT, bitmap->bytesPerPixel()); 241 uploadToTexture(resize, GL_RGB, bitmap->rowBytesAsPixels(), texture->height, 242 GL_UNSIGNED_SHORT_5_6_5, bitmap->getPixels()); 243 texture->blend = false; 244 break; 245 case SkBitmap::kARGB_8888_Config: 246 glPixelStorei(GL_UNPACK_ALIGNMENT, bitmap->bytesPerPixel()); 247 uploadToTexture(resize, GL_RGBA, bitmap->rowBytesAsPixels(), texture->height, 248 GL_UNSIGNED_BYTE, bitmap->getPixels()); 249 // Do this after calling getPixels() to make sure Skia's deferred 250 // decoding happened 251 texture->blend = !bitmap->isOpaque(); 252 break; 253 case SkBitmap::kARGB_4444_Config: 254 case SkBitmap::kIndex8_Config: 255 glPixelStorei(GL_UNPACK_ALIGNMENT, bitmap->bytesPerPixel()); 256 uploadLoFiTexture(resize, bitmap, texture->width, texture->height); 257 texture->blend = !bitmap->isOpaque(); 258 break; 259 default: 260 ALOGW("Unsupported bitmap config: %d", bitmap->getConfig()); 261 break; 262 } 263 264 if (!regenerate) { 265 texture->setFilter(GL_NEAREST); 266 texture->setWrap(GL_CLAMP_TO_EDGE); 267 } 268} 269 270void TextureCache::uploadLoFiTexture(bool resize, SkBitmap* bitmap, 271 uint32_t width, uint32_t height) { 272 SkBitmap rgbaBitmap; 273 rgbaBitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height); 274 rgbaBitmap.allocPixels(); 275 rgbaBitmap.eraseColor(0); 276 rgbaBitmap.setIsOpaque(bitmap->isOpaque()); 277 278 SkCanvas canvas(rgbaBitmap); 279 canvas.drawBitmap(*bitmap, 0.0f, 0.0f, NULL); 280 281 uploadToTexture(resize, GL_RGBA, rgbaBitmap.rowBytesAsPixels(), height, 282 GL_UNSIGNED_BYTE, rgbaBitmap.getPixels()); 283} 284 285void TextureCache::uploadToTexture(bool resize, GLenum format, GLsizei width, GLsizei height, 286 GLenum type, const GLvoid * data) { 287 if (resize) { 288 glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, type, data); 289 } else { 290 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, format, type, data); 291 } 292} 293 294}; // namespace uirenderer 295}; // namespace android 296