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
TextureCache()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
TextureCache(uint32_t maxByteSize)59 TextureCache::TextureCache(uint32_t maxByteSize):
60 mCache(GenerationCache<SkBitmap*, Texture*>::kUnlimitedCapacity),
61 mSize(0), mMaxSize(maxByteSize) {
62 init();
63 }
64
~TextureCache()65 TextureCache::~TextureCache() {
66 mCache.clear();
67 }
68
init()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
getSize()82 uint32_t TextureCache::getSize() {
83 return mSize;
84 }
85
getMaxSize()86 uint32_t TextureCache::getMaxSize() {
87 return mMaxSize;
88 }
89
setMaxSize(uint32_t maxSize)90 void TextureCache::setMaxSize(uint32_t maxSize) {
91 mMaxSize = maxSize;
92 while (mSize > mMaxSize) {
93 mCache.removeOldest();
94 }
95 }
96
setFlushRate(float flushRate)97 void TextureCache::setFlushRate(float flushRate) {
98 mFlushRate = fmaxf(0.0f, fminf(1.0f, flushRate));
99 }
100
101 ///////////////////////////////////////////////////////////////////////////////
102 // Callbacks
103 ///////////////////////////////////////////////////////////////////////////////
104
operator ()(SkBitmap * & bitmap,Texture * & texture)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 ALOGD("Texture deleted, size = %d", texture->bitmapSize);
113 }
114 glDeleteTextures(1, &texture->id);
115 delete texture;
116 }
117 }
118
119 ///////////////////////////////////////////////////////////////////////////////
120 // Caching
121 ///////////////////////////////////////////////////////////////////////////////
122
get(SkBitmap * bitmap)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 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
getTransient(SkBitmap * bitmap)163 Texture* 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
remove(SkBitmap * bitmap)173 void TextureCache::remove(SkBitmap* bitmap) {
174 mCache.remove(bitmap);
175 }
176
removeDeferred(SkBitmap * bitmap)177 void TextureCache::removeDeferred(SkBitmap* bitmap) {
178 Mutex::Autolock _l(mLock);
179 mGarbage.push(bitmap);
180 }
181
clearGarbage()182 void 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
clear()191 void TextureCache::clear() {
192 mCache.clear();
193 TEXTURE_LOGD("TextureCache:clear(), mSize = %d", mSize);
194 }
195
flush()196 void 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
generateTexture(SkBitmap * bitmap,Texture * texture,bool regenerate)211 void 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 if (!regenerate) {
232 glPixelStorei(GL_UNPACK_ALIGNMENT, bitmap->bytesPerPixel());
233 }
234
235 switch (bitmap->getConfig()) {
236 case SkBitmap::kA8_Config:
237 if (!regenerate) {
238 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
239 }
240 uploadToTexture(resize, GL_ALPHA, bitmap->rowBytesAsPixels(), texture->height,
241 GL_UNSIGNED_BYTE, bitmap->getPixels());
242 texture->blend = true;
243 break;
244 case SkBitmap::kRGB_565_Config:
245 uploadToTexture(resize, GL_RGB, bitmap->rowBytesAsPixels(), texture->height,
246 GL_UNSIGNED_SHORT_5_6_5, bitmap->getPixels());
247 texture->blend = false;
248 break;
249 case SkBitmap::kARGB_8888_Config:
250 uploadToTexture(resize, GL_RGBA, bitmap->rowBytesAsPixels(), texture->height,
251 GL_UNSIGNED_BYTE, bitmap->getPixels());
252 // Do this after calling getPixels() to make sure Skia's deferred
253 // decoding happened
254 texture->blend = !bitmap->isOpaque();
255 break;
256 case SkBitmap::kARGB_4444_Config:
257 case SkBitmap::kIndex8_Config:
258 uploadLoFiTexture(resize, bitmap, texture->width, texture->height);
259 texture->blend = !bitmap->isOpaque();
260 break;
261 default:
262 ALOGW("Unsupported bitmap config: %d", bitmap->getConfig());
263 break;
264 }
265
266 if (!regenerate) {
267 texture->setFilter(GL_NEAREST);
268 texture->setWrap(GL_CLAMP_TO_EDGE);
269 }
270 }
271
uploadLoFiTexture(bool resize,SkBitmap * bitmap,uint32_t width,uint32_t height)272 void TextureCache::uploadLoFiTexture(bool resize, SkBitmap* bitmap,
273 uint32_t width, uint32_t height) {
274 SkBitmap rgbaBitmap;
275 rgbaBitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
276 rgbaBitmap.allocPixels();
277 rgbaBitmap.eraseColor(0);
278 rgbaBitmap.setIsOpaque(bitmap->isOpaque());
279
280 SkCanvas canvas(rgbaBitmap);
281 canvas.drawBitmap(*bitmap, 0.0f, 0.0f, NULL);
282
283 uploadToTexture(resize, GL_RGBA, rgbaBitmap.rowBytesAsPixels(), height,
284 GL_UNSIGNED_BYTE, rgbaBitmap.getPixels());
285 }
286
uploadToTexture(bool resize,GLenum format,GLsizei width,GLsizei height,GLenum type,const GLvoid * data)287 void TextureCache::uploadToTexture(bool resize, GLenum format, GLsizei width, GLsizei height,
288 GLenum type, const GLvoid * data) {
289 if (resize) {
290 glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, type, data);
291 } else {
292 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, format, type, data);
293 }
294 }
295
296 }; // namespace uirenderer
297 }; // namespace android
298