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 #define ATRACE_TAG ATRACE_TAG_VIEW 19 20 #include <GLES2/gl2.h> 21 22 #include <SkCanvas.h> 23 #include <SkPixelRef.h> 24 25 #include <utils/Mutex.h> 26 27 #include "AssetAtlas.h" 28 #include "Caches.h" 29 #include "Texture.h" 30 #include "TextureCache.h" 31 #include "Properties.h" 32 #include "utils/TraceUtils.h" 33 34 namespace android { 35 namespace uirenderer { 36 37 /////////////////////////////////////////////////////////////////////////////// 38 // Constructors/destructor 39 /////////////////////////////////////////////////////////////////////////////// 40 41 TextureCache::TextureCache() 42 : mCache(LruCache<uint32_t, Texture*>::kUnlimitedCapacity) 43 , mSize(0) 44 , mMaxSize(MB(DEFAULT_TEXTURE_CACHE_SIZE)) 45 , mFlushRate(DEFAULT_TEXTURE_CACHE_FLUSH_RATE) 46 , mAssetAtlas(nullptr) { 47 char property[PROPERTY_VALUE_MAX]; 48 if (property_get(PROPERTY_TEXTURE_CACHE_SIZE, property, nullptr) > 0) { 49 INIT_LOGD(" Setting texture cache size to %sMB", property); 50 setMaxSize(MB(atof(property))); 51 } else { 52 INIT_LOGD(" Using default texture cache size of %.2fMB", DEFAULT_TEXTURE_CACHE_SIZE); 53 } 54 55 if (property_get(PROPERTY_TEXTURE_CACHE_FLUSH_RATE, property, nullptr) > 0) { 56 float flushRate = atof(property); 57 INIT_LOGD(" Setting texture cache flush rate to %.2f%%", flushRate * 100.0f); 58 setFlushRate(flushRate); 59 } else { 60 INIT_LOGD(" Using default texture cache flush rate of %.2f%%", 61 DEFAULT_TEXTURE_CACHE_FLUSH_RATE * 100.0f); 62 } 63 64 mCache.setOnEntryRemovedListener(this); 65 66 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize); 67 INIT_LOGD(" Maximum texture dimension is %d pixels", mMaxTextureSize); 68 69 mDebugEnabled = Properties::debugLevel & kDebugCaches; 70 } 71 72 TextureCache::~TextureCache() { 73 mCache.clear(); 74 } 75 76 /////////////////////////////////////////////////////////////////////////////// 77 // Size management 78 /////////////////////////////////////////////////////////////////////////////// 79 80 uint32_t TextureCache::getSize() { 81 return mSize; 82 } 83 84 uint32_t TextureCache::getMaxSize() { 85 return mMaxSize; 86 } 87 88 void TextureCache::setMaxSize(uint32_t maxSize) { 89 mMaxSize = maxSize; 90 while (mSize > mMaxSize) { 91 mCache.removeOldest(); 92 } 93 } 94 95 void TextureCache::setFlushRate(float flushRate) { 96 mFlushRate = std::max(0.0f, std::min(1.0f, flushRate)); 97 } 98 99 /////////////////////////////////////////////////////////////////////////////// 100 // Callbacks 101 /////////////////////////////////////////////////////////////////////////////// 102 103 void TextureCache::operator()(uint32_t&, Texture*& texture) { 104 // This will be called already locked 105 if (texture) { 106 mSize -= texture->bitmapSize; 107 TEXTURE_LOGD("TextureCache::callback: name, removed size, mSize = %d, %d, %d", 108 texture->id, texture->bitmapSize, mSize); 109 if (mDebugEnabled) { 110 ALOGD("Texture deleted, size = %d", texture->bitmapSize); 111 } 112 texture->deleteTexture(); 113 delete texture; 114 } 115 } 116 117 /////////////////////////////////////////////////////////////////////////////// 118 // Caching 119 /////////////////////////////////////////////////////////////////////////////// 120 121 void TextureCache::setAssetAtlas(AssetAtlas* assetAtlas) { 122 mAssetAtlas = assetAtlas; 123 } 124 125 void TextureCache::resetMarkInUse(void* ownerToken) { 126 LruCache<uint32_t, Texture*>::Iterator iter(mCache); 127 while (iter.next()) { 128 if (iter.value()->isInUse == ownerToken) { 129 iter.value()->isInUse = nullptr; 130 } 131 } 132 } 133 134 bool TextureCache::canMakeTextureFromBitmap(const SkBitmap* bitmap) { 135 if (bitmap->width() > mMaxTextureSize || bitmap->height() > mMaxTextureSize) { 136 ALOGW("Bitmap too large to be uploaded into a texture (%dx%d, max=%dx%d)", 137 bitmap->width(), bitmap->height(), mMaxTextureSize, mMaxTextureSize); 138 return false; 139 } 140 return true; 141 } 142 143 // Returns a prepared Texture* that either is already in the cache or can fit 144 // in the cache (and is thus added to the cache) 145 Texture* TextureCache::getCachedTexture(const SkBitmap* bitmap, AtlasUsageType atlasUsageType) { 146 if (CC_LIKELY(mAssetAtlas != nullptr) && atlasUsageType == AtlasUsageType::Use) { 147 AssetAtlas::Entry* entry = mAssetAtlas->getEntry(bitmap); 148 if (CC_UNLIKELY(entry)) { 149 return entry->texture; 150 } 151 } 152 153 Texture* texture = mCache.get(bitmap->pixelRef()->getStableID()); 154 155 if (!texture) { 156 if (!canMakeTextureFromBitmap(bitmap)) { 157 return nullptr; 158 } 159 160 const uint32_t size = bitmap->rowBytes() * bitmap->height(); 161 bool canCache = size < mMaxSize; 162 // Don't even try to cache a bitmap that's bigger than the cache 163 while (canCache && mSize + size > mMaxSize) { 164 Texture* oldest = mCache.peekOldestValue(); 165 if (oldest && !oldest->isInUse) { 166 mCache.removeOldest(); 167 } else { 168 canCache = false; 169 } 170 } 171 172 if (canCache) { 173 texture = new Texture(Caches::getInstance()); 174 texture->bitmapSize = size; 175 generateTexture(bitmap, texture, false); 176 177 mSize += size; 178 TEXTURE_LOGD("TextureCache::get: create texture(%p): name, size, mSize = %d, %d, %d", 179 bitmap, texture->id, size, mSize); 180 if (mDebugEnabled) { 181 ALOGD("Texture created, size = %d", size); 182 } 183 mCache.put(bitmap->pixelRef()->getStableID(), texture); 184 } 185 } else if (!texture->isInUse && bitmap->getGenerationID() != texture->generation) { 186 // Texture was in the cache but is dirty, re-upload 187 // TODO: Re-adjust the cache size if the bitmap's dimensions have changed 188 generateTexture(bitmap, texture, true); 189 } 190 191 return texture; 192 } 193 194 bool TextureCache::prefetchAndMarkInUse(void* ownerToken, const SkBitmap* bitmap) { 195 Texture* texture = getCachedTexture(bitmap, AtlasUsageType::Use); 196 if (texture) { 197 texture->isInUse = ownerToken; 198 } 199 return texture; 200 } 201 202 Texture* TextureCache::get(const SkBitmap* bitmap, AtlasUsageType atlasUsageType) { 203 Texture* texture = getCachedTexture(bitmap, atlasUsageType); 204 205 if (!texture) { 206 if (!canMakeTextureFromBitmap(bitmap)) { 207 return nullptr; 208 } 209 210 const uint32_t size = bitmap->rowBytes() * bitmap->height(); 211 texture = new Texture(Caches::getInstance()); 212 texture->bitmapSize = size; 213 generateTexture(bitmap, texture, false); 214 texture->cleanup = true; 215 } 216 217 return texture; 218 } 219 220 void TextureCache::releaseTexture(uint32_t pixelRefStableID) { 221 Mutex::Autolock _l(mLock); 222 mGarbage.push(pixelRefStableID); 223 } 224 225 void TextureCache::clearGarbage() { 226 Mutex::Autolock _l(mLock); 227 size_t count = mGarbage.size(); 228 for (size_t i = 0; i < count; i++) { 229 uint32_t pixelRefId = mGarbage.itemAt(i); 230 mCache.remove(pixelRefId); 231 } 232 mGarbage.clear(); 233 } 234 235 void TextureCache::clear() { 236 mCache.clear(); 237 TEXTURE_LOGD("TextureCache:clear(), mSize = %d", mSize); 238 } 239 240 void TextureCache::flush() { 241 if (mFlushRate >= 1.0f || mCache.size() == 0) return; 242 if (mFlushRate <= 0.0f) { 243 clear(); 244 return; 245 } 246 247 uint32_t targetSize = uint32_t(mSize * mFlushRate); 248 TEXTURE_LOGD("TextureCache::flush: target size: %d", targetSize); 249 250 while (mSize > targetSize) { 251 mCache.removeOldest(); 252 } 253 } 254 255 void TextureCache::generateTexture(const SkBitmap* bitmap, Texture* texture, bool regenerate) { 256 SkAutoLockPixels alp(*bitmap); 257 258 if (!bitmap->readyToDraw()) { 259 ALOGE("Cannot generate texture from bitmap"); 260 return; 261 } 262 263 ATRACE_FORMAT("Upload %ux%u Texture", bitmap->width(), bitmap->height()); 264 265 // We could also enable mipmapping if both bitmap dimensions are powers 266 // of 2 but we'd have to deal with size changes. Let's keep this simple 267 const bool canMipMap = Caches::getInstance().extensions().hasNPot(); 268 269 // If the texture had mipmap enabled but not anymore, 270 // force a glTexImage2D to discard the mipmap levels 271 const bool resize = !regenerate || bitmap->width() != int(texture->width) || 272 bitmap->height() != int(texture->height) || 273 (regenerate && canMipMap && texture->mipMap && !bitmap->hasHardwareMipMap()); 274 275 if (!regenerate) { 276 glGenTextures(1, &texture->id); 277 } 278 279 texture->generation = bitmap->getGenerationID(); 280 texture->width = bitmap->width(); 281 texture->height = bitmap->height(); 282 283 Caches::getInstance().textureState().bindTexture(texture->id); 284 285 switch (bitmap->colorType()) { 286 case kAlpha_8_SkColorType: 287 uploadToTexture(resize, GL_ALPHA, bitmap->rowBytesAsPixels(), bitmap->bytesPerPixel(), 288 texture->width, texture->height, GL_UNSIGNED_BYTE, bitmap->getPixels()); 289 texture->blend = true; 290 break; 291 case kRGB_565_SkColorType: 292 uploadToTexture(resize, GL_RGB, bitmap->rowBytesAsPixels(), bitmap->bytesPerPixel(), 293 texture->width, texture->height, GL_UNSIGNED_SHORT_5_6_5, bitmap->getPixels()); 294 texture->blend = false; 295 break; 296 case kN32_SkColorType: 297 uploadToTexture(resize, GL_RGBA, bitmap->rowBytesAsPixels(), bitmap->bytesPerPixel(), 298 texture->width, texture->height, GL_UNSIGNED_BYTE, bitmap->getPixels()); 299 // Do this after calling getPixels() to make sure Skia's deferred 300 // decoding happened 301 texture->blend = !bitmap->isOpaque(); 302 break; 303 case kARGB_4444_SkColorType: 304 case kIndex_8_SkColorType: 305 uploadLoFiTexture(resize, bitmap, texture->width, texture->height); 306 texture->blend = !bitmap->isOpaque(); 307 break; 308 default: 309 ALOGW("Unsupported bitmap colorType: %d", bitmap->colorType()); 310 break; 311 } 312 313 if (canMipMap) { 314 texture->mipMap = bitmap->hasHardwareMipMap(); 315 if (texture->mipMap) { 316 glGenerateMipmap(GL_TEXTURE_2D); 317 } 318 } 319 320 if (!regenerate) { 321 texture->setFilter(GL_NEAREST); 322 texture->setWrap(GL_CLAMP_TO_EDGE); 323 } 324 } 325 326 void TextureCache::uploadLoFiTexture(bool resize, const SkBitmap* bitmap, 327 uint32_t width, uint32_t height) { 328 SkBitmap rgbaBitmap; 329 rgbaBitmap.allocPixels(SkImageInfo::MakeN32(width, height, bitmap->alphaType())); 330 rgbaBitmap.eraseColor(0); 331 332 SkCanvas canvas(rgbaBitmap); 333 canvas.drawBitmap(*bitmap, 0.0f, 0.0f, nullptr); 334 335 uploadToTexture(resize, GL_RGBA, rgbaBitmap.rowBytesAsPixels(), rgbaBitmap.bytesPerPixel(), 336 width, height, GL_UNSIGNED_BYTE, rgbaBitmap.getPixels()); 337 } 338 339 void TextureCache::uploadToTexture(bool resize, GLenum format, GLsizei stride, GLsizei bpp, 340 GLsizei width, GLsizei height, GLenum type, const GLvoid * data) { 341 glPixelStorei(GL_UNPACK_ALIGNMENT, bpp); 342 const bool useStride = stride != width 343 && Caches::getInstance().extensions().hasUnpackRowLength(); 344 if ((stride == width) || useStride) { 345 if (useStride) { 346 glPixelStorei(GL_UNPACK_ROW_LENGTH, stride); 347 } 348 349 if (resize) { 350 glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, type, data); 351 } else { 352 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, format, type, data); 353 } 354 355 if (useStride) { 356 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); 357 } 358 } else { 359 // With OpenGL ES 2.0 we need to copy the bitmap in a temporary buffer 360 // if the stride doesn't match the width 361 362 GLvoid * temp = (GLvoid *) malloc(width * height * bpp); 363 if (!temp) return; 364 365 uint8_t * pDst = (uint8_t *)temp; 366 uint8_t * pSrc = (uint8_t *)data; 367 for (GLsizei i = 0; i < height; i++) { 368 memcpy(pDst, pSrc, width * bpp); 369 pDst += width * bpp; 370 pSrc += stride * bpp; 371 } 372 373 if (resize) { 374 glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, type, temp); 375 } else { 376 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, format, type, temp); 377 } 378 379 free(temp); 380 } 381 } 382 383 }; // namespace uirenderer 384 }; // namespace android 385