TextureCache.cpp revision 8f9a9f61ab793d9387a5942b307e74324704893b
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 LOGD("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 LOGW("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 LOGD("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 163void TextureCache::remove(SkBitmap* bitmap) { 164 mCache.remove(bitmap); 165} 166 167void TextureCache::removeDeferred(SkBitmap* bitmap) { 168 Mutex::Autolock _l(mLock); 169 mGarbage.push(bitmap); 170} 171 172void TextureCache::clearGarbage() { 173 Mutex::Autolock _l(mLock); 174 size_t count = mGarbage.size(); 175 for (size_t i = 0; i < count; i++) { 176 mCache.remove(mGarbage.itemAt(i)); 177 } 178 mGarbage.clear(); 179} 180 181void TextureCache::clear() { 182 mCache.clear(); 183 TEXTURE_LOGD("TextureCache:clear(), mSize = %d", mSize); 184} 185 186void TextureCache::flush() { 187 if (mFlushRate >= 1.0f || mCache.size() == 0) return; 188 if (mFlushRate <= 0.0f) { 189 clear(); 190 return; 191 } 192 193 uint32_t targetSize = uint32_t(mSize * mFlushRate); 194 TEXTURE_LOGD("TextureCache::flush: target size: %d", targetSize); 195 196 while (mSize > targetSize) { 197 mCache.removeOldest(); 198 } 199} 200 201void TextureCache::generateTexture(SkBitmap* bitmap, Texture* texture, bool regenerate) { 202 SkAutoLockPixels alp(*bitmap); 203 204 if (!bitmap->readyToDraw()) { 205 LOGE("Cannot generate texture from bitmap"); 206 return; 207 } 208 209 const bool resize = !regenerate || bitmap->width() != int(texture->width) || 210 bitmap->height() != int(texture->height); 211 212 if (!regenerate) { 213 glGenTextures(1, &texture->id); 214 } 215 216 texture->generation = bitmap->getGenerationID(); 217 texture->width = bitmap->width(); 218 texture->height = bitmap->height(); 219 220 glBindTexture(GL_TEXTURE_2D, texture->id); 221 if (!regenerate) { 222 glPixelStorei(GL_UNPACK_ALIGNMENT, bitmap->bytesPerPixel()); 223 } 224 225 switch (bitmap->getConfig()) { 226 case SkBitmap::kA8_Config: 227 if (!regenerate) { 228 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 229 } 230 uploadToTexture(resize, GL_ALPHA, bitmap->rowBytesAsPixels(), texture->height, 231 GL_UNSIGNED_BYTE, bitmap->getPixels()); 232 texture->blend = true; 233 break; 234 case SkBitmap::kRGB_565_Config: 235 uploadToTexture(resize, GL_RGB, bitmap->rowBytesAsPixels(), texture->height, 236 GL_UNSIGNED_SHORT_5_6_5, bitmap->getPixels()); 237 texture->blend = false; 238 break; 239 case SkBitmap::kARGB_8888_Config: 240 uploadToTexture(resize, GL_RGBA, bitmap->rowBytesAsPixels(), texture->height, 241 GL_UNSIGNED_BYTE, bitmap->getPixels()); 242 // Do this after calling getPixels() to make sure Skia's deferred 243 // decoding happened 244 texture->blend = !bitmap->isOpaque(); 245 break; 246 case SkBitmap::kARGB_4444_Config: 247 case SkBitmap::kIndex8_Config: 248 uploadLoFiTexture(resize, bitmap, texture->width, texture->height); 249 texture->blend = !bitmap->isOpaque(); 250 break; 251 default: 252 LOGW("Unsupported bitmap config: %d", bitmap->getConfig()); 253 break; 254 } 255 256 if (!regenerate) { 257 texture->setFilter(GL_NEAREST); 258 texture->setWrap(GL_CLAMP_TO_EDGE); 259 } 260} 261 262void TextureCache::uploadLoFiTexture(bool resize, SkBitmap* bitmap, 263 uint32_t width, uint32_t height) { 264 SkBitmap rgbaBitmap; 265 rgbaBitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height); 266 rgbaBitmap.allocPixels(); 267 rgbaBitmap.eraseColor(0); 268 rgbaBitmap.setIsOpaque(bitmap->isOpaque()); 269 270 SkCanvas canvas(rgbaBitmap); 271 canvas.drawBitmap(*bitmap, 0.0f, 0.0f, NULL); 272 273 uploadToTexture(resize, GL_RGBA, rgbaBitmap.rowBytesAsPixels(), height, 274 GL_UNSIGNED_BYTE, rgbaBitmap.getPixels()); 275} 276 277void TextureCache::uploadToTexture(bool resize, GLenum format, GLsizei width, GLsizei height, 278 GLenum type, const GLvoid * data) { 279 if (resize) { 280 glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, type, data); 281 } else { 282 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, format, type, data); 283 } 284} 285 286}; // namespace uirenderer 287}; // namespace android 288